gloomberb 0.3.3 → 0.4.0

package/src/cli/index.ts

@@ -1,12 +1,16 @@
 import { VERSION } from "../version";
+import type { CliCommandDef, CliDispatchResult } from "../types/plugin";
+import type { LoadedExternalPlugin } from "../plugins/loader";
+import { loadCliConfigIfAvailable } from "./context";
 import {
-  cliStyles,
-  renderSection,
-  renderTable,
-} from "../utils/cli-output";
+  buildCliCommandRegistry,
+  createCliCommandContext,
+  normalizeCliCommandToken,
+  normalizeCliDispatchResult,
+  renderCliHelp,
+  type CliCommandRegistry,
+} from "./registry";
 import { fail } from "./errors";
-import { portfolio } from "./commands/portfolio";
-import { watchlist } from "./commands/watchlist";
 import { search, searchCandidatesForCli, buildSearchReport } from "./commands/search";
 import { ticker, buildTickerReport } from "./commands/ticker";
 import {
@@ -16,128 +20,141 @@ import {
   updatePlugins,
 } from "./commands/plugins";
 
-function help() {
-  console.log(`${cliStyles.bold(`gloomberb v${VERSION}`)}\n${cliStyles.muted("Bloomberg-style portfolio tracker for the terminal")}`);
-  console.log("");
-  console.log(renderSection("Usage"));
-  console.log("gloomberb [command]");
-  console.log("");
-  console.log(renderSection("Commands"));
-  console.log(renderTable(
-    [
-      { header: "Command" },
-      { header: "Description" },
-    ],
-    [
-      ["(no command)", "Launch the terminal UI"],
-      ["predictions [...]", "Launch the UI with Prediction Markets focused"],
-      ["help", "Show this help message"],
-      ["portfolio [name]", "List collections or show a portfolio/watchlist"],
-      ["watchlist [action]", "List, create, delete, add, or remove watchlists"],
-      ["search <query>", "Search tickers and company names"],
-      ["ticker <symbol>", "Show quote, ownership, and detailed financials"],
-      ["install <user/repo>", "Install a plugin from GitHub"],
-      ["remove <name>", "Remove an installed plugin"],
-      ["update [name]", "Update plugins"],
-      ["plugins", "List installed plugins"],
-    ],
-  ));
-  console.log("");
-  console.log(renderSection("Prediction Launch"));
-  console.log(renderTable(
-    [
-      { header: "Input" },
-      { header: "Example" },
-    ],
-    [
-      ["gloomberb predictions [venue] [category] [browse-tab] [search...]", "gloomberb predictions world"],
-      ["venue", "all | polymarket | kalshi"],
-      ["category", "all | politics | world | macro | crypto | science | sports | entertainment | climate | social"],
-      ["browse-tab", "top | ending | new | watchlist"],
-    ],
-  ));
-  console.log("");
-  console.log(renderSection("Watchlist Actions"));
-  console.log(renderTable(
-    [
-      { header: "Action" },
-      { header: "Example" },
-    ],
-    [
-      ["list", "gloomberb watchlist list"],
-      ["show", "gloomberb watchlist show Growth"],
-      ["create", "gloomberb watchlist create Growth"],
-      ["delete", "gloomberb watchlist delete Growth"],
-      ["add", "gloomberb watchlist add Growth NVDA"],
-      ["remove", "gloomberb watchlist remove Growth NVDA"],
-    ],
-  ));
+function createCoreCliCommands(renderHelp: () => string): CliCommandDef[] {
+  return [
+    {
+      name: "help",
+      aliases: ["--help", "-h"],
+      description: "Show this help message",
+      help: {
+        usage: ["help"],
+      },
+      execute: () => {
+        console.log(renderHelp());
+      },
+    },
+    {
+      name: "search",
+      description: "Search tickers and company names",
+      help: {
+        usage: ["search <query>"],
+      },
+      execute: async (args, ctx) => {
+        const query = args.join(" ");
+        await search(query, {
+          initMarketData: ctx.initMarketData,
+          fail: ctx.fail,
+        });
+      },
+    },
+    {
+      name: "ticker",
+      description: "Show quote, ownership, and detailed financials",
+      help: {
+        usage: ["ticker <symbol>"],
+      },
+      execute: async (args, ctx) => {
+        const symbol = args[0];
+        if (!symbol) {
+          ctx.fail("Usage: gloomberb ticker <symbol>");
+        }
+        await ticker(symbol!, {
+          initMarketData: ctx.initMarketData,
+          closeAndFail: ctx.closeAndFail,
+        });
+      },
+    },
+    {
+      name: "install",
+      description: "Install a plugin from GitHub",
+      help: {
+        usage: ["install <user/repo>"],
+      },
+      execute: async (args) => {
+        const ref = args[0];
+        if (!ref) {
+          fail("Usage: gloomberb install <github-user/repo>");
+        }
+        await installPlugin(ref);
+      },
+    },
+    {
+      name: "remove",
+      aliases: ["uninstall"],
+      description: "Remove an installed plugin",
+      help: {
+        usage: ["remove <name>"],
+      },
+      execute: async (args) => {
+        const name = args[0];
+        if (!name) {
+          fail("Usage: gloomberb remove <plugin-name>");
+        }
+        await removePlugin(name);
+      },
+    },
+    {
+      name: "update",
+      description: "Update plugins",
+      help: {
+        usage: ["update [name]"],
+      },
+      execute: async (args) => {
+        await updatePlugins(args[0]);
+      },
+    },
+    {
+      name: "plugins",
+      aliases: ["list"],
+      description: "List installed plugins",
+      help: {
+        usage: ["plugins"],
+      },
+      execute: () => {
+        listPlugins();
+      },
+    },
+  ];
+}
+
+export interface DispatchCliOptions {
+  externalPlugins?: LoadedExternalPlugin[];
+}
+
+async function createRegistry(options: DispatchCliOptions = {}): Promise<CliCommandRegistry> {
+  const config = await loadCliConfigIfAvailable();
+  let registry: CliCommandRegistry | null = null;
+  const coreCommands = createCoreCliCommands(() => renderCliHelp(registry!, VERSION));
+  registry = buildCliCommandRegistry({
+    coreCommands,
+    externalPlugins: options.externalPlugins ?? [],
+    config,
+  });
+  return registry;
 }
 
 export { buildSearchReport, buildTickerReport, searchCandidatesForCli };
 
-export async function runCli(args: string[]): Promise<boolean> {
+export async function dispatchCli(args: string[], options: DispatchCliOptions = {}): Promise<CliDispatchResult> {
   const command = args[0];
+  if (!command) {
+    return { kind: "unhandled" };
+  }
 
-  switch (command) {
-    case "help":
-    case "--help":
-    case "-h": {
-      help();
-      return true;
-    }
-    case "portfolio": {
-      await portfolio(args.slice(1).join(" ") || undefined);
-      return true;
-    }
-    case "watchlist":
-    case "watchlists": {
-      await watchlist(args.slice(1));
-      return true;
-    }
-    case "search": {
-      const query = args.slice(1).join(" ");
-      if (!query) {
-        fail("Usage: gloomberb search <query>");
-      }
-      await search(query);
-      return true;
-    }
-    case "ticker": {
-      const symbol = args[1];
-      if (!symbol) {
-        fail("Usage: gloomberb ticker <symbol>");
-      }
-      await ticker(symbol);
-      return true;
-    }
-    case "install": {
-      const ref = args[1];
-      if (!ref) {
-        fail("Usage: gloomberb install <github-user/repo>");
-      }
-      await installPlugin(ref);
-      return true;
-    }
-    case "remove":
-    case "uninstall": {
-      const name = args[1];
-      if (!name) {
-        fail("Usage: gloomberb remove <plugin-name>");
-      }
-      await removePlugin(name);
-      return true;
-    }
-    case "update": {
-      await updatePlugins(args[1]);
-      return true;
-    }
-    case "plugins":
-    case "list": {
-      listPlugins();
-      return true;
-    }
-    default:
-      return false;
+  const registry = await createRegistry(options);
+  const resolved = registry.lookup.get(normalizeCliCommandToken(command));
+  if (!resolved) {
+    return { kind: "unhandled" };
   }
+
+  const result = await resolved.command.execute(
+    args.slice(1),
+    createCliCommandContext(resolved.ownerId, registry.plugins),
+  );
+  return normalizeCliDispatchResult(result);
+}
+
+export async function runCli(args: string[], options: DispatchCliOptions = {}): Promise<boolean> {
+  const result = await dispatchCli(args, options);
+  return result.kind === "handled";
 }

package/src/cli/registry.test.ts

@@ -0,0 +1,226 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+import { createDefaultConfig } from "../types/config";
+import type { GloomPlugin } from "../types/plugin";
+import type { LoadedExternalPlugin } from "../plugins/loader";
+import {
+  buildCliCommandRegistry,
+  createCliCommandContext,
+  normalizeCliCommandToken,
+  renderCliHelp,
+} from "./registry";
+import { dispatchCli } from "./index";
+import { applyPredictionLaunchIntentToConfig, applyPredictionLaunchIntentToSessionSnapshot, parsePredictionCommandArgs } from "../plugins/prediction-markets/launch";
+
+const tempDirs: string[] = [];
+const originalHome = process.env.HOME;
+
+afterEach(async () => {
+  process.env.HOME = originalHome;
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+async function createTempHome(prefix: string): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+async function captureConsole<T>(fn: () => Promise<T> | T): Promise<{ result: T; stdout: string; stderr: string }> {
+  const logs: string[] = [];
+  const errors: string[] = [];
+  const originalLog = console.log;
+  const originalError = console.error;
+
+  console.log = (...args: unknown[]) => {
+    logs.push(args.map(String).join(" "));
+  };
+  console.error = (...args: unknown[]) => {
+    errors.push(args.map(String).join(" "));
+  };
+
+  try {
+    const result = await fn();
+    return {
+      result,
+      stdout: logs.join("\n"),
+      stderr: errors.join("\n"),
+    };
+  } finally {
+    console.log = originalLog;
+    console.error = originalError;
+  }
+}
+
+function createSyntheticPlugin(commandName = "example"): GloomPlugin {
+  return {
+    id: "synthetic-cli",
+    name: "Synthetic CLI",
+    version: "1.0.0",
+    cliCommands: [{
+      name: commandName,
+      aliases: ["alias-example"],
+      description: "Synthetic plugin command",
+      help: {
+        usage: [`${commandName} [value]`],
+        sections: [{
+          title: "Synthetic Help",
+          lines: ["Hello from the synthetic plugin."],
+        }],
+      },
+      execute: async (args, ctx) => {
+        console.log(`${ctx.log ? "ok" : "missing"}:${args.join(" ")}`);
+      },
+    }],
+  };
+}
+
+describe("CLI registry", () => {
+  test("indexes plugin commands and aliases from the registry", () => {
+    const registry = buildCliCommandRegistry({
+      coreCommands: [],
+      externalPlugins: [{
+        plugin: createSyntheticPlugin(),
+        path: "/tmp/synthetic-cli",
+      }],
+      config: null,
+    });
+
+    expect(registry.lookup.get(normalizeCliCommandToken("example"))?.ownerId).toBe("synthetic-cli");
+    expect(registry.lookup.get(normalizeCliCommandToken("alias-example"))?.ownerId).toBe("synthetic-cli");
+  });
+
+  test("rejects duplicate command names and aliases", () => {
+    expect(() => buildCliCommandRegistry({
+      coreCommands: [{
+        name: "duplicate",
+        description: "Core command",
+        execute: async () => {},
+      }],
+      externalPlugins: [{
+        plugin: {
+          id: "dup-plugin",
+          name: "Duplicate",
+          version: "1.0.0",
+          cliCommands: [{
+            name: "other",
+            aliases: ["duplicate"],
+            description: "Plugin command",
+            execute: async () => {},
+          }],
+        },
+        path: "/tmp/dup-plugin",
+      }],
+      config: null,
+    })).toThrow(/duplicate/i);
+  });
+
+  test("omits disabled plugin commands from help and dispatch lookup", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-cli-disabled");
+    config.disabledPlugins = ["synthetic-cli"];
+
+    const registry = buildCliCommandRegistry({
+      coreCommands: [],
+      externalPlugins: [{
+        plugin: createSyntheticPlugin(),
+        path: "/tmp/synthetic-cli",
+      }],
+      config,
+    });
+
+    expect(registry.lookup.get("example")).toBeUndefined();
+    expect(renderCliHelp(registry, "0.0.0")).not.toContain("Synthetic plugin command");
+  });
+
+  test("ignores broken external plugins while keeping other commands available", () => {
+    const registry = buildCliCommandRegistry({
+      coreCommands: [{
+        name: "core-only",
+        description: "Core command",
+        execute: async () => {},
+      }],
+      externalPlugins: [{
+        plugin: {
+          id: "broken",
+          name: "Broken Plugin",
+          version: "0.0.0",
+        },
+        path: "/tmp/broken",
+        error: "Failed to load plugin",
+      }],
+      config: null,
+    });
+
+    expect(registry.lookup.get("core-only")?.ownerId).toBe("core");
+    expect(registry.lookup.get("broken")).toBeUndefined();
+    expect(registry.commands.some((entry) => entry.ownerId === "core")).toBe(true);
+  });
+
+  test("creates plugin-scoped command contexts", async () => {
+    const context = createCliCommandContext("synthetic-cli", [createSyntheticPlugin()]);
+    expect(context.log).toBeDefined();
+    expect(context.output.renderSection("Test")).toContain("Test");
+  });
+});
+
+describe("CLI dispatch", () => {
+  test("dispatches a synthetic plugin command without main CLI changes", async () => {
+    process.env.HOME = await createTempHome("gloomberb-cli-registry-home-");
+
+    const { result, stdout } = await captureConsole(() => dispatchCli(
+      ["example", "hello", "world"],
+      {
+        externalPlugins: [{
+          plugin: createSyntheticPlugin(),
+          path: "/tmp/synthetic-cli",
+        }],
+      },
+    ));
+
+    expect(result).toEqual({ kind: "handled" });
+    expect(stdout).toContain("ok:hello world");
+  });
+
+  test("routes prediction market commands and aliases through launch-ui requests", async () => {
+    process.env.HOME = await createTempHome("gloomberb-cli-prediction-home-");
+
+    for (const rootCommand of ["predictions", "prediction-markets", "pm"]) {
+      const dispatchResult = await dispatchCli([rootCommand, "world"]);
+      expect(dispatchResult.kind).toBe("launch-ui");
+      if (dispatchResult.kind !== "launch-ui") continue;
+
+      const config = createDefaultConfig("/tmp/gloomberb-cli-prediction");
+      const intent = parsePredictionCommandArgs(["world"]);
+      const expectedConfigResult = applyPredictionLaunchIntentToConfig(config, intent, {
+        width: 132,
+        height: 40,
+      });
+      const actualConfigResult = dispatchResult.request.applyConfig(config, {
+        terminalWidth: 132,
+        terminalHeight: 40,
+      });
+
+      expect(actualConfigResult.config).toEqual(expectedConfigResult.config);
+      expect(actualConfigResult.launchState).toEqual({
+        paneInstanceId: expectedConfigResult.paneInstanceId,
+        intent,
+      });
+
+      const expectedSession = applyPredictionLaunchIntentToSessionSnapshot(
+        actualConfigResult.config,
+        null,
+        expectedConfigResult.paneInstanceId,
+        intent,
+      );
+      const actualSession = dispatchResult.request.applySessionSnapshot?.(
+        actualConfigResult.config,
+        null,
+        actualConfigResult.launchState,
+      );
+
+      expect(actualSession).toEqual(expectedSession);
+    }
+  });
+});