gloomberb 0.1.0 → 0.3.1

package/src/plugins/builtin/ai/index.tsx

@@ -0,0 +1,86 @@
+import type { GloomPlugin } from "../../../types/plugin";
+import { detectProviders } from "./providers";
+import { AskAiDetailTab } from "./ask-ai-detail-tab";
+import { AiScreenerPane } from "./screener-pane";
+import { buildAiScreenerPaneSettingsDef, getAiScreenerPaneSettings } from "./settings";
+
+export const aiPlugin: GloomPlugin = {
+  id: "ai",
+  name: "AI",
+  version: "1.0.0",
+  description: "Use local AI CLI with your financial data.",
+  toggleable: true,
+
+  setup(ctx) {
+    const detectedProviders = detectProviders();
+    const selectableProviders = detectedProviders.filter((provider) => provider.available);
+    const providerOptions = (selectableProviders.length > 0 ? selectableProviders : detectedProviders)
+      .map((provider) => ({
+        label: provider.name,
+        value: provider.id,
+      }));
+    const defaultProviderId = providerOptions[0]?.value ?? "claude";
+
+    ctx.registerDetailTab({
+      id: "ai-chat",
+      name: "Ask AI",
+      order: 60,
+      component: AskAiDetailTab,
+    });
+
+    ctx.registerPane({
+      id: "ai-screener",
+      name: "AI Screener",
+      icon: "A",
+      component: AiScreenerPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 76, height: 24 },
+      settings: (context) => buildAiScreenerPaneSettingsDef(
+        getAiScreenerPaneSettings(context.settings),
+      ),
+    });
+
+    ctx.registerPaneTemplate({
+      id: "new-ai-screener-pane",
+      paneId: "ai-screener",
+      label: "AI Screener",
+      description: "Create a prompt-driven AI screener pane with reusable screening tabs.",
+      keywords: ["ai", "screener", "screen", "watchlist", "prompt"],
+      shortcut: { prefix: "AI", argPlaceholder: "prompt", argKind: "text" },
+      wizard: [
+        {
+          key: "providerId",
+          label: "AI Provider",
+          type: "select",
+          defaultValue: defaultProviderId,
+          options: providerOptions,
+          body: ["Choose which local AI CLI should run the initial screener."],
+        },
+        {
+          key: "prompt",
+          label: "Screener Prompt",
+          type: "textarea",
+          placeholder: "Examples: humanoid robot suppliers, defense software compounders, EM payment rails, obesity-drug picks-and-shovels...",
+          body: [
+            "Describe the screening idea in plain English.",
+            "The AI will return validated ticker ideas with a short reason for each one.",
+          ],
+        },
+      ],
+      createInstance: (_context, options) => {
+        const prompt = options?.values?.prompt?.trim() || options?.arg?.trim() || "";
+        if (!prompt) return null;
+        const providerId = options?.values?.providerId || defaultProviderId;
+        return {
+          title: "AI Screener",
+          placement: "floating",
+          params: {
+            prompt,
+            providerId,
+          },
+        };
+      },
+    });
+  },
+};

package/src/plugins/builtin/ai/providers.ts

@@ -0,0 +1,99 @@
+import { execSync } from "child_process";
+
+export interface AiProvider {
+  id: string;
+  name: string;
+  command: string;
+  available: boolean;
+  buildArgs: (prompt: string) => string[];
+}
+
+export interface AiProviderDefinition extends Omit<AiProvider, "available"> {}
+
+const PROVIDER_DEFS: AiProviderDefinition[] = [
+  {
+    id: "claude",
+    name: "Claude",
+    command: "claude",
+    buildArgs: (prompt) => ["-p", prompt],
+  },
+  {
+    id: "gemini",
+    name: "Gemini",
+    command: "gemini",
+    buildArgs: (prompt) => ["-p", prompt],
+  },
+  {
+    id: "codex",
+    name: "Codex",
+    command: "codex",
+    buildArgs: (prompt) => ["exec", prompt],
+  },
+];
+
+let detectedProviders: AiProvider[] | null = null;
+
+function commandExists(command: string): boolean {
+  try {
+    if (typeof Bun !== "undefined" && typeof Bun.which === "function") {
+      return !!Bun.which(command);
+    }
+  } catch {
+    // Fall back to shell lookup when Bun.which is unavailable.
+  }
+
+  try {
+    execSync(`command -v ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function detectProviders(): AiProvider[] {
+  if (detectedProviders) return detectedProviders;
+
+  detectedProviders = PROVIDER_DEFS.map((definition) => ({
+    ...definition,
+    available: commandExists(definition.command),
+  }));
+  return detectedProviders;
+}
+
+export function getAvailableProviders(providers = detectProviders()): AiProvider[] {
+  return providers.filter((provider) => provider.available);
+}
+
+export function getAiProvider(providerId: string | null | undefined, providers = detectProviders()): AiProvider | null {
+  if (!providerId) return null;
+  return providers.find((provider) => provider.id === providerId) ?? null;
+}
+
+export function resolveDefaultAiProviderId(providers = detectProviders()): string {
+  return getAvailableProviders(providers)[0]?.id ?? providers[0]?.id ?? "claude";
+}
+
+export function listAiProviderOptions(
+  preferredId?: string | null,
+  providers = detectProviders(),
+): Array<{ label: string; value: string }> {
+  const ordered = [...providers].sort((left, right) => {
+    if (left.id === preferredId) return -1;
+    if (right.id === preferredId) return 1;
+    if (left.available !== right.available) return left.available ? -1 : 1;
+    return left.name.localeCompare(right.name);
+  });
+
+  return ordered.map((provider) => ({
+    value: provider.id,
+    label: provider.available ? provider.name : `${provider.name} (missing)`,
+  }));
+}
+
+export function __setDetectedProvidersForTests(providers: AiProvider[] | null): void {
+  detectedProviders = providers;
+}
+
+export function getAiProviderDefinitions(): AiProviderDefinition[] {
+  return PROVIDER_DEFS.map((definition) => ({ ...definition }));
+}

package/src/plugins/builtin/ai/runner.ts

@@ -0,0 +1,82 @@
+import { spawn, type Subprocess } from "bun";
+import type { AiProvider } from "./providers";
+
+export class AiRunCancelledError extends Error {
+  constructor() {
+    super("AI run cancelled");
+    this.name = "AiRunCancelledError";
+  }
+}
+
+export interface AiRunController {
+  done: Promise<string>;
+  cancel: () => void;
+}
+
+export function isAiRunCancelled(error: unknown): boolean {
+  return error instanceof AiRunCancelledError;
+}
+
+export function runAiPrompt({
+  provider,
+  prompt,
+  cwd = process.cwd(),
+  onChunk,
+}: {
+  provider: AiProvider;
+  prompt: string;
+  cwd?: string;
+  onChunk?: (output: string) => void;
+}): AiRunController {
+  let cancelled = false;
+  let processRef: Subprocess | null = null;
+
+  const done = (async () => {
+    const proc = spawn([provider.command, ...provider.buildArgs(prompt)], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    processRef = proc;
+
+    const stderrPromise = new Response(proc.stderr).text().catch(() => "");
+    const stdoutReader = proc.stdout.getReader();
+    const decoder = new TextDecoder();
+    let fullOutput = "";
+
+    while (true) {
+      const { done: streamDone, value } = await stdoutReader.read();
+      if (streamDone) break;
+      if (cancelled) throw new AiRunCancelledError();
+      fullOutput += decoder.decode(value, { stream: true });
+      onChunk?.(fullOutput);
+    }
+
+    const exitCode = await proc.exited;
+    const stderr = (await stderrPromise).trim();
+
+    if (cancelled) throw new AiRunCancelledError();
+    if (exitCode !== 0) {
+      throw new Error(stderr || fullOutput.trim() || `${provider.name} exited with status ${exitCode}.`);
+    }
+
+    const finalOutput = fullOutput.trim();
+    if (!finalOutput) {
+      throw new Error(stderr || `${provider.name} returned an empty response.`);
+    }
+
+    return finalOutput;
+  })();
+
+  return {
+    done,
+    cancel: () => {
+      cancelled = true;
+      try {
+        processRef?.kill();
+      } catch {
+        // ignore cleanup failures
+      }
+    },
+  };
+}

package/src/plugins/builtin/ai/screener-contract.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, test } from "bun:test";
+import { buildGloomberbCliInstructions, resolveGloomberbCliCommand } from "./gloomberb-cli";
+import {
+  buildScreenerPrompt,
+  mergeScreenerResults,
+  parseScreenerResponse,
+} from "./screener-contract";
+import type { AiProvider } from "./providers";
+
+const TEST_PROVIDER: AiProvider = {
+  id: "claude",
+  name: "Claude",
+  command: "claude",
+  available: true,
+  buildArgs: () => [],
+};
+
+describe("AI screener helpers", () => {
+  test("prefers the installed gloomberb command when it exists", () => {
+    const command = resolveGloomberbCliCommand({
+      cwd: "/tmp/project",
+      hasCommand: (value) => value === "gloomberb",
+      fileExists: () => true,
+    });
+
+    expect(command).toEqual({
+      argv: ["gloomberb"],
+      display: "gloomberb",
+      mode: "installed",
+    });
+  });
+
+  test("falls back to bun source mode while developing locally", () => {
+    const command = resolveGloomberbCliCommand({
+      cwd: "/tmp/project",
+      hasCommand: () => false,
+      fileExists: (path) => path === "/tmp/project/src/index.tsx",
+    });
+
+    expect(command).toEqual({
+      argv: ["bun", "/tmp/project/src/index.tsx"],
+      display: "bun /tmp/project/src/index.tsx",
+      mode: "bun-source",
+    });
+    expect(buildGloomberbCliInstructions(command)).toContain("Inspect a portfolio or watchlist with: bun /tmp/project/src/index.tsx portfolio [name]");
+  });
+
+  test("builds a screener prompt with the current date and prior results", () => {
+    const prompt = buildScreenerPrompt({
+      currentDate: "2026-04-01",
+      prompt: "Find profitable serial acquirers.",
+      provider: TEST_PROVIDER,
+      cliInstructions: [
+        "Useful commands: gloomberb help",
+        "Inspect a ticker with: gloomberb ticker <symbol>",
+      ],
+      previousResults: [
+        {
+          symbol: "CSU",
+          exchange: "TSX",
+          reason: "Recurring software roll-up.",
+          resolvedName: "Constellation Software",
+        },
+      ],
+      includePreviousResults: true,
+    });
+
+    expect(prompt).toContain("Today is 2026-04-01.");
+    expect(prompt).toContain("You are running in the Claude CLI.");
+    expect(prompt).toContain("Useful commands: gloomberb help");
+    expect(prompt).toContain("CSU (TSX): Recurring software roll-up.");
+    expect(prompt).toContain("Return raw JSON only.");
+  });
+
+  test("parses fenced JSON responses and normalizes ticker fields", () => {
+    const parsed = parseScreenerResponse(`
+\`\`\`json
+{
+  "title": "Compounders",
+  "summary": "High quality names",
+  "tickers": [
+    { "symbol": " msft ", "exchange": " nasdaq ", "reason": "Recurring software cash flow" }
+  ]
+}
+\`\`\`
+`);
+
+    expect(parsed).toEqual({
+      title: "Compounders",
+      summary: "High quality names",
+      tickers: [
+        {
+          symbol: "MSFT",
+          exchange: "NASDAQ",
+          reason: "Recurring software cash flow",
+        },
+      ],
+    });
+  });
+
+  test("merges reruns by updating duplicates and appending new symbols", () => {
+    const merged = mergeScreenerResults(
+      [
+        { symbol: "AAPL", exchange: "NASDAQ", reason: "Old reason", resolvedName: "Apple Inc." },
+      ],
+      [
+        { symbol: "AAPL", exchange: "NASDAQ", reason: "Updated reason", resolvedName: "Apple Inc." },
+        { symbol: "MSFT", exchange: "NASDAQ", reason: "New result", resolvedName: "Microsoft Corp." },
+      ],
+    );
+
+    expect(merged).toEqual([
+      { symbol: "AAPL", exchange: "NASDAQ", reason: "Updated reason", resolvedName: "Apple Inc." },
+      { symbol: "MSFT", exchange: "NASDAQ", reason: "New result", resolvedName: "Microsoft Corp." },
+    ]);
+  });
+});

package/src/plugins/builtin/ai/screener-contract.ts

@@ -0,0 +1,174 @@
+import type { AiProvider } from "./providers";
+import { truncateWithEllipsis } from "./utils";
+
+export interface ScreenerCandidate {
+  symbol: string;
+  exchange: string;
+  reason: string;
+}
+
+export interface ParsedScreenerResponse {
+  title: string | null;
+  summary: string | null;
+  tickers: ScreenerCandidate[];
+}
+
+export interface ValidatedScreenerResult {
+  symbol: string;
+  exchange: string;
+  reason: string;
+  resolvedName: string;
+}
+
+function tryParseJson(raw: string): unknown | null {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+
+  const candidates = [
+    trimmed,
+    trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1]?.trim() ?? null,
+  ].filter((candidate): candidate is string => !!candidate);
+
+  const firstBrace = trimmed.indexOf("{");
+  const lastBrace = trimmed.lastIndexOf("}");
+  if (firstBrace >= 0 && lastBrace > firstBrace) {
+    candidates.push(trimmed.slice(firstBrace, lastBrace + 1));
+  }
+
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+      // try next parse candidate
+    }
+  }
+  return null;
+}
+
+function normalizeString(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+export function deriveScreenerTitle(prompt: string): string {
+  const normalized = prompt
+    .split(/\s+/)
+    .join(" ")
+    .trim();
+  return truncateWithEllipsis(normalized || "New Screener", 22);
+}
+
+export function getScreenerPromptSignature(prompt: string, providerId: string): string {
+  return JSON.stringify([providerId.trim(), prompt.trim()]);
+}
+
+export function buildScreenerPrompt({
+  currentDate,
+  prompt,
+  provider,
+  cliInstructions,
+  previousResults,
+  includePreviousResults,
+}: {
+  currentDate: string;
+  prompt: string;
+  provider: AiProvider;
+  cliInstructions: string[];
+  previousResults: ValidatedScreenerResult[];
+  includePreviousResults: boolean;
+}): string {
+  const lines = [
+    `Today is ${currentDate}.`,
+    `You are running in the ${provider.name} CLI.`,
+    "",
+    "Find public-market tickers that match this screening prompt:",
+    prompt.trim(),
+    "",
+    "You may use the local Gloomberb CLI to validate companies before returning them:",
+    ...cliInstructions.map((instruction) => `- ${instruction}`),
+    "",
+  ];
+
+  if (includePreviousResults && previousResults.length > 0) {
+    lines.push("These tickers were already found for this exact screener. Prefer new names if you can validate them:");
+    for (const result of previousResults) {
+      lines.push(`- ${result.symbol} (${result.exchange}): ${result.reason}`);
+    }
+    lines.push("");
+  }
+
+  lines.push(
+    "Return raw JSON only. Do not wrap it in markdown or add commentary.",
+    "Schema:",
+    '{ "title": "optional short title", "summary": "optional one-line summary", "tickers": [{ "symbol": "AAPL", "exchange": "NASDAQ", "reason": "concise reason" }] }',
+    "Rules:",
+    "- Return at most 25 unique ticker candidates.",
+    "- Use uppercase symbols.",
+    "- `reason` must be concise and specific.",
+    "- Omit any company you cannot validate with confidence.",
+  );
+
+  return lines.join("\n");
+}
+
+export function parseScreenerResponse(raw: string): ParsedScreenerResponse {
+  const parsed = tryParseJson(raw);
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("AI screener returned invalid JSON.");
+  }
+
+  const payload = parsed as Record<string, unknown>;
+  const tickersRaw = Array.isArray(payload.tickers) ? payload.tickers : null;
+  if (!tickersRaw) {
+    throw new Error("AI screener JSON did not include a `tickers` array.");
+  }
+
+  const tickers = tickersRaw
+    .map((entry) => {
+      if (!entry || typeof entry !== "object") return null;
+      const candidate = entry as Record<string, unknown>;
+      const symbol = normalizeString(candidate.symbol).toUpperCase();
+      const exchange = normalizeString(candidate.exchange).toUpperCase();
+      const reason = normalizeString(candidate.reason);
+      if (!symbol) return null;
+      return {
+        symbol,
+        exchange,
+        reason: reason || "No reason provided.",
+      } satisfies ScreenerCandidate;
+    })
+    .filter((entry): entry is ScreenerCandidate => entry != null)
+    .slice(0, 25);
+
+  return {
+    title: normalizeString(payload.title) || null,
+    summary: normalizeString(payload.summary) || null,
+    tickers,
+  };
+}
+
+export function mergeScreenerResults(
+  previous: ValidatedScreenerResult[],
+  next: ValidatedScreenerResult[],
+): ValidatedScreenerResult[] {
+  const nextBySymbol = new Map(next.map((result) => [result.symbol, result] as const));
+  const merged: ValidatedScreenerResult[] = [];
+
+  for (const result of previous) {
+    const replacement = nextBySymbol.get(result.symbol);
+    if (replacement) {
+      merged.push(replacement);
+      nextBySymbol.delete(result.symbol);
+      continue;
+    }
+    merged.push(result);
+  }
+
+  for (const result of next) {
+    if (nextBySymbol.has(result.symbol)) {
+      merged.push(result);
+      nextBySymbol.delete(result.symbol);
+    }
+  }
+
+  return merged;
+}