gloomberb 0.3.3 → 0.4.0

package/src/cli/registry.ts

@@ -0,0 +1,201 @@
+import type { AppConfig } from "../types/config";
+import type { CliCommandContext, CliCommandDef, CliDispatchResult, GloomPlugin } from "../types/plugin";
+import type { LoadedExternalPlugin } from "../plugins/loader";
+import { getPluginCatalog } from "../plugins/catalog";
+import { initConfigData, initMarketData } from "./context";
+import { closeAndFail, fail } from "./errors";
+import {
+  cliStyles,
+  colorBySign,
+  renderSection,
+  renderStat,
+  renderTable,
+} from "../utils/cli-output";
+import { debugLog } from "../utils/debug-log";
+
+const registryLog = debugLog.createLogger("cli-registry");
+
+export interface RegisteredCliCommand {
+  command: CliCommandDef;
+  ownerId: string;
+  source: "core" | "plugin";
+}
+
+export interface CliCommandRegistry {
+  commands: RegisteredCliCommand[];
+  lookup: ReadonlyMap<string, RegisteredCliCommand>;
+  config: AppConfig | null;
+  plugins: GloomPlugin[];
+}
+
+interface BuildCliCommandRegistryOptions {
+  coreCommands: CliCommandDef[];
+  externalPlugins?: LoadedExternalPlugin[];
+  config?: AppConfig | null;
+}
+
+export function normalizeCliCommandToken(token: string): string {
+  return token.trim().toLowerCase();
+}
+
+function describeCommandOwner(ownerId: string, source: "core" | "plugin"): string {
+  return source === "core" ? `core CLI (${ownerId})` : `plugin "${ownerId}"`;
+}
+
+function validateCommandToken(token: string, ownerId: string, source: "core" | "plugin"): string {
+  const normalized = normalizeCliCommandToken(token);
+  if (!normalized) {
+    throw new Error(`CLI command token for ${describeCommandOwner(ownerId, source)} cannot be empty.`);
+  }
+  return normalized;
+}
+
+export function normalizeCliDispatchResult(result: void | CliDispatchResult): CliDispatchResult {
+  if (!result) {
+    return { kind: "handled" };
+  }
+  return result;
+}
+
+function getCommandUsageLabel(command: CliCommandDef): string {
+  return command.help?.usage?.[0] ?? command.name;
+}
+
+function renderHelpSections(registry: CliCommandRegistry): string[] {
+  const lines: string[] = [];
+
+  for (const { command } of registry.commands) {
+    const sections = command.help?.sections ?? [];
+    for (const section of sections) {
+      lines.push("");
+      lines.push(renderSection(section.title));
+      if (section.lines && section.lines.length > 0) {
+        lines.push(...section.lines);
+      }
+      if (section.columns && section.rows) {
+        lines.push(renderTable(section.columns, section.rows));
+      }
+    }
+  }
+
+  return lines;
+}
+
+export function renderCliHelp(registry: CliCommandRegistry, version: string): string {
+  const lines = [
+    `${cliStyles.bold(`gloomberb v${version}`)}\n${cliStyles.muted("Bloomberg-style portfolio tracker for the terminal")}`,
+    "",
+    renderSection("Usage"),
+    "gloomberb [command]",
+    "",
+    renderSection("Commands"),
+    renderTable(
+      [
+        { header: "Command" },
+        { header: "Description" },
+      ],
+      [
+        ["(no command)", "Launch the terminal UI"],
+        ...registry.commands.map(({ command }) => [
+          getCommandUsageLabel(command),
+          command.description,
+        ]),
+      ],
+    ),
+  ];
+
+  lines.push(...renderHelpSections(registry));
+  return lines.join("\n");
+}
+
+export function buildCliCommandRegistry({
+  coreCommands,
+  externalPlugins = [],
+  config = null,
+}: BuildCliCommandRegistryOptions): CliCommandRegistry {
+  const allCommands: RegisteredCliCommand[] = [];
+  const allTokens = new Map<string, RegisteredCliCommand>();
+  const catalog = getPluginCatalog(externalPlugins);
+  const disabledPlugins = new Set(config?.disabledPlugins ?? []);
+
+  const registerCommand = (
+    command: CliCommandDef,
+    ownerId: string,
+    source: "core" | "plugin",
+  ) => {
+    const tokens = new Set([
+      validateCommandToken(command.name, ownerId, source),
+      ...(command.aliases ?? []).map((alias) => validateCommandToken(alias, ownerId, source)),
+    ]);
+
+    for (const token of tokens) {
+      const existing = allTokens.get(token);
+      if (!existing) continue;
+      throw new Error(
+        `CLI command token "${token}" is declared by both `
+        + `${describeCommandOwner(existing.ownerId, existing.source)} and ${describeCommandOwner(ownerId, source)}.`,
+      );
+    }
+
+    const entry: RegisteredCliCommand = { command, ownerId, source };
+    allCommands.push(entry);
+    for (const token of tokens) {
+      allTokens.set(token, entry);
+    }
+  };
+
+  for (const command of coreCommands) {
+    registerCommand(command, "core", "core");
+  }
+
+  const loadablePlugins: GloomPlugin[] = [];
+  for (const entry of catalog) {
+    if (entry.error) {
+      registryLog.warn(`Skipping external plugin "${entry.plugin.id}" for CLI registration.`, {
+        path: entry.path,
+        error: entry.error,
+      });
+      continue;
+    }
+    loadablePlugins.push(entry.plugin);
+    for (const command of entry.plugin.cliCommands ?? []) {
+      registerCommand(command, entry.plugin.id, "plugin");
+    }
+  }
+
+  const commands = allCommands.filter((entry) => (
+    entry.source === "core" || !disabledPlugins.has(entry.ownerId)
+  ));
+
+  const lookup = new Map<string, RegisteredCliCommand>();
+  for (const entry of commands) {
+    lookup.set(normalizeCliCommandToken(entry.command.name), entry);
+    for (const alias of entry.command.aliases ?? []) {
+      lookup.set(normalizeCliCommandToken(alias), entry);
+    }
+  }
+
+  return {
+    commands,
+    lookup,
+    config,
+    plugins: loadablePlugins,
+  };
+}
+
+export function createCliCommandContext(ownerId: string, plugins: GloomPlugin[]): CliCommandContext {
+  return {
+    initConfigData,
+    initMarketData: () => initMarketData({ plugins }),
+    fail,
+    closeAndFail,
+    output: {
+      cliStyles,
+      colorBySign,
+      renderSection,
+      renderStat,
+      renderTable,
+    },
+    log: debugLog.createLogger(ownerId === "core" ? "cli" : ownerId),
+  };
+}

package/src/cli.test.ts

@@ -32,11 +32,15 @@ async function createTempDir(prefix: string): Promise<string> {
 }
 
 async function createCliFixture({
+  portfolios,
   watchlists,
   tickers = [],
+  baseCurrency,
 }: {
+  portfolios?: Array<{ id: string; name: string; currency: string; brokerId?: string; brokerInstanceId?: string; brokerAccountId?: string }>;
   watchlists: Array<{ id: string; name: string }>;
   tickers?: TickerRecord[];
+  baseCurrency?: string;
 }) {
   const homeDir = await createTempDir("gloomberb-cli-home-");
   const dataDir = await createTempDir("gloomberb-cli-data-");
@@ -46,6 +50,12 @@ async function createCliFixture({
   await writeFile(join(homeDir, ".gloomberb", "config.json"), JSON.stringify({ dataDir }), "utf-8");
 
   const config = createDefaultConfig(dataDir);
+  if (baseCurrency) {
+    config.baseCurrency = baseCurrency;
+  }
+  if (portfolios) {
+    config.portfolios = portfolios;
+  }
   config.watchlists = watchlists;
   await saveConfig(config);
 
@@ -85,6 +95,39 @@ async function captureConsole<T>(fn: () => Promise<T> | T): Promise<{ result: T;
   }
 }
 
+async function captureConsoleFailure(fn: () => Promise<unknown> | unknown): Promise<{ stdout: string; stderr: string; error: unknown }> {
+  const logs: string[] = [];
+  const errors: string[] = [];
+  const originalLog = console.log;
+  const originalError = console.error;
+  const originalExit = process.exit;
+
+  console.log = (...args: unknown[]) => {
+    logs.push(args.map(String).join(" "));
+  };
+  console.error = (...args: unknown[]) => {
+    errors.push(args.map(String).join(" "));
+  };
+  process.exit = ((code?: number) => {
+    throw new Error(`process.exit:${code ?? 0}`);
+  }) as typeof process.exit;
+
+  try {
+    await fn();
+    throw new Error("Expected command to fail.");
+  } catch (error) {
+    return {
+      stdout: logs.join("\n"),
+      stderr: errors.join("\n"),
+      error,
+    };
+  } finally {
+    console.log = originalLog;
+    console.error = originalError;
+    process.exit = originalExit;
+  }
+}
+
 function makeTicker(overrides: Partial<TickerRecord["metadata"]> = {}): TickerRecord {
   return {
     metadata: {
@@ -110,6 +153,8 @@ describe("CLI watchlist commands", () => {
     expect(stdout).toContain("predictions [...]");
     expect(stdout).toContain("Prediction Launch");
     expect(stdout).toContain("gloomberb predictions world");
+    expect(stdout).toContain("Portfolio Actions");
+    expect(stdout).toContain("Watchlist Actions");
   });
 
   test("creates a watchlist and persists the generated id", async () => {
@@ -155,6 +200,180 @@ describe("CLI watchlist commands", () => {
   });
 });
 
+describe("CLI portfolio commands", () => {
+  test("creates a manual portfolio and persists the generated id", async () => {
+    const { dataDir } = await createCliFixture({
+      portfolios: [{ id: "main", name: "Main Portfolio", currency: "USD" }],
+      watchlists: [],
+    });
+
+    const { stdout } = await captureConsole(() => runCli(["portfolio", "create", "Research"]));
+    const config = await loadConfig(dataDir);
+
+    expect(config.portfolios).toEqual([
+      { id: "main", name: "Main Portfolio", currency: "USD" },
+      { id: "research", name: "Research", currency: "USD" },
+    ]);
+    expect(stdout).toContain('Created portfolio "Research".');
+    expect(stdout).toContain("research");
+  });
+
+  test("rejects duplicate manual portfolio names", async () => {
+    await createCliFixture({
+      portfolios: [{ id: "research", name: "Research", currency: "USD" }],
+      watchlists: [],
+    });
+
+    const result = await captureConsoleFailure(() => runCli(["portfolio", "create", "Research"]));
+    expect(String(result.error)).toContain("process.exit:1");
+    expect(result.stderr).toContain('Portfolio "Research" already exists.');
+  });
+
+  test("adds a ticker to a manual portfolio and supports legacy show", async () => {
+    const { dataDir } = await createCliFixture({
+      portfolios: [{ id: "research", name: "Research", currency: "USD" }],
+      watchlists: [],
+      tickers: [makeTicker()],
+    });
+
+    const addResult = await captureConsole(() => runCli(["portfolio", "add", "Research", "NVDA"]));
+    expect(addResult.stdout).toContain('Added NVDA to "Research".');
+
+    let persistence = new AppPersistence(join(dataDir, ".gloomberb-cache.db"));
+    let store = new TickerRepository(persistence.tickers);
+    let savedTicker = await store.loadTicker("NVDA");
+    persistence.close();
+
+    expect(savedTicker?.metadata.portfolios).toEqual(["research"]);
+
+    const showResult = await captureConsole(() => runCli(["portfolio", "Research"]));
+    expect(showResult.stdout).toContain("Research (USD)");
+    expect(showResult.stdout).toContain("NVDA");
+  });
+
+  test("sets and replaces a manual position for a portfolio ticker", async () => {
+    const { dataDir } = await createCliFixture({
+      portfolios: [{ id: "research", name: "Research", currency: "USD" }],
+      watchlists: [],
+      tickers: [makeTicker()],
+      baseCurrency: "USD",
+    });
+
+    const first = await captureConsole(() => runCli(["portfolio", "position", "set", "Research", "NVDA", "10", "400"]));
+    expect(first.stdout).toContain('Set position for NVDA in "Research".');
+    expect(first.stdout).toContain("Shares");
+    expect(first.stdout).toContain("10");
+
+    const second = await captureConsole(() => runCli(["portfolio", "position", "set", "Research", "NVDA", "12", "405", "EUR"]));
+    expect(second.stdout).toContain("EUR");
+
+    const persistence = new AppPersistence(join(dataDir, ".gloomberb-cache.db"));
+    const store = new TickerRepository(persistence.tickers);
+    const savedTicker = await store.loadTicker("NVDA");
+    persistence.close();
+
+    expect(savedTicker?.metadata.portfolios).toEqual(["research"]);
+    expect(savedTicker?.metadata.positions).toEqual([{
+      portfolio: "research",
+      shares: 12,
+      avgCost: 405,
+      currency: "EUR",
+      broker: "manual",
+    }]);
+  });
+
+  test("removes portfolio membership and positions, then cleans all references on delete", async () => {
+    const { dataDir } = await createCliFixture({
+      portfolios: [
+        { id: "main", name: "Main Portfolio", currency: "USD" },
+        { id: "research", name: "Research", currency: "USD" },
+      ],
+      watchlists: [],
+      tickers: [
+        makeTicker({
+          ticker: "NVDA",
+          portfolios: ["research"],
+          positions: [{
+            portfolio: "research",
+            shares: 5,
+            avgCost: 350,
+            currency: "USD",
+            broker: "manual",
+          }],
+        }),
+        makeTicker({
+          ticker: "ASML",
+          portfolios: ["research", "main"],
+          positions: [{
+            portfolio: "research",
+            shares: 3,
+            avgCost: 700,
+            currency: "USD",
+            broker: "manual",
+          }, {
+            portfolio: "main",
+            shares: 1,
+            avgCost: 650,
+            currency: "USD",
+            broker: "manual",
+          }],
+        }),
+      ],
+    });
+
+    const removeResult = await captureConsole(() => runCli(["portfolio", "remove", "Research", "NVDA"]));
+    expect(removeResult.stdout).toContain('Removed NVDA from "Research".');
+    expect(removeResult.stdout).toContain("Removed Positions");
+
+    let persistence = new AppPersistence(join(dataDir, ".gloomberb-cache.db"));
+    let store = new TickerRepository(persistence.tickers);
+    let savedTicker = await store.loadTicker("NVDA");
+    persistence.close();
+
+    expect(savedTicker?.metadata.portfolios).toEqual([]);
+    expect(savedTicker?.metadata.positions).toEqual([]);
+
+    const deleteResult = await captureConsole(() => runCli(["portfolio", "delete", "Research"]));
+    expect(deleteResult.stdout).toContain('Deleted portfolio "Research".');
+    expect(deleteResult.stdout).toContain("Removed Positions");
+
+    const config = await loadConfig(dataDir);
+    expect(config.portfolios).toEqual([{ id: "main", name: "Main Portfolio", currency: "USD" }]);
+
+    persistence = new AppPersistence(join(dataDir, ".gloomberb-cache.db"));
+    store = new TickerRepository(persistence.tickers);
+    savedTicker = await store.loadTicker("ASML");
+    persistence.close();
+
+    expect(savedTicker?.metadata.portfolios).toEqual(["main"]);
+    expect(savedTicker?.metadata.positions).toEqual([{
+      portfolio: "main",
+      shares: 1,
+      avgCost: 650,
+      currency: "USD",
+      broker: "manual",
+    }]);
+  });
+
+  test("rejects broker-managed portfolio mutations", async () => {
+    await createCliFixture({
+      portfolios: [{
+        id: "broker:ibkr:acct",
+        name: "IBKR Account",
+        currency: "USD",
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-live",
+      }],
+      watchlists: [],
+      tickers: [makeTicker()],
+    });
+
+    const result = await captureConsoleFailure(() => runCli(["portfolio", "add", "IBKR Account", "NVDA"]));
+    expect(String(result.error)).toContain("process.exit:1");
+    expect(result.stderr).toContain('Portfolio "IBKR Account" is broker-managed and cannot be modified manually.');
+  });
+});
+
 describe("buildTickerReport", () => {
   test("includes deeper fundamentals and recent statement sections", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-cli-report");