opencandle 0.2.0 → 0.4.0

package/gui/server/model-setup.ts

@@ -0,0 +1,100 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+
+export type ModelSetupRequirement = "ready" | "select_model" | "connect_auth";
+
+export interface ModelSetupProvider {
+  id: string;
+  label: string;
+  envVar: string;
+  defaultProvider: string;
+  defaultModel: string;
+  signupUrl: string;
+}
+
+export interface ModelSetupState {
+  requirement: ModelSetupRequirement;
+  currentModel?: string;
+  providers: ModelSetupProvider[];
+  availableModels: Array<{ provider: string; id: string; label: string }>;
+}
+
+export interface ModelSetupRegistry {
+  refresh(): void;
+  getAvailable(): Model<Api>[];
+  hasConfiguredAuth(model: Model<Api>): boolean;
+}
+
+export const modelSetupProviders: ModelSetupProvider[] = [
+  {
+    id: "google",
+    label: "Google Gemini",
+    envVar: "GEMINI_API_KEY",
+    defaultProvider: "google",
+    defaultModel: "gemini-2.5-flash",
+    signupUrl: "https://aistudio.google.com/app/apikey",
+  },
+  {
+    id: "openai",
+    label: "OpenAI",
+    envVar: "OPENAI_API_KEY",
+    defaultProvider: "openai",
+    defaultModel: "gpt-5-mini",
+    signupUrl: "https://platform.openai.com/api-keys",
+  },
+  {
+    id: "anthropic",
+    label: "Anthropic",
+    envVar: "ANTHROPIC_API_KEY",
+    defaultProvider: "anthropic",
+    defaultModel: "claude-haiku-4-5",
+    signupUrl: "https://console.anthropic.com/settings/keys",
+  },
+];
+
+export function buildModelSetupState(
+  registry: ModelSetupRegistry,
+  currentModel: Model<Api> | undefined,
+): ModelSetupState {
+  registry.refresh();
+  const availableModels = sortModels(registry.getAvailable()).map((model) => ({
+    provider: model.provider,
+    id: model.id,
+    label: `${model.provider}/${model.id}`,
+  }));
+  const requirement =
+    currentModel && registry.hasConfiguredAuth(currentModel)
+      ? "ready"
+      : availableModels.length > 0
+        ? "select_model"
+        : "connect_auth";
+
+  return {
+    requirement,
+    currentModel: currentModel ? `${currentModel.provider}/${currentModel.id}` : undefined,
+    providers: modelSetupProviders,
+    availableModels,
+  };
+}
+
+export function findPreferredModel(
+  registry: Pick<ModelSetupRegistry, "getAvailable">,
+  provider: ModelSetupProvider,
+): Model<Api> | undefined {
+  const available = sortModels(registry.getAvailable(), provider.defaultProvider);
+  return (
+    available.find(
+      (model) =>
+        model.provider === provider.defaultProvider && model.id === provider.defaultModel,
+    ) ?? available.find((model) => model.provider === provider.defaultProvider)
+  );
+}
+
+export function sortModels(models: Model<Api>[], preferredProvider?: string): Model<Api>[] {
+  return [...models].sort((a, b) => {
+    const aPreferred = preferredProvider && a.provider === preferredProvider ? -1 : 0;
+    const bPreferred = preferredProvider && b.provider === preferredProvider ? -1 : 0;
+    if (aPreferred !== bPreferred) return aPreferred - bPreferred;
+    const byProvider = a.provider.localeCompare(b.provider);
+    return byProvider !== 0 ? byProvider : a.id.localeCompare(b.id);
+  });
+}

package/gui/server/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@opencandle/gui-server",
+  "private": true,
+  "type": "module"
+}

package/gui/server/projector.ts

@@ -0,0 +1,212 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { Message, ToolResultMessage } from "@earendil-works/pi-ai";
+
+export interface DashboardState {
+  watchlist: Array<{
+    symbol: string;
+    quote: Record<string, unknown> | null;
+    pinned: boolean;
+    lastSeen: string;
+  }>;
+  activeAnalyses: Array<{
+    workflowId: string;
+    workflow: string;
+    symbol?: string;
+    analystsTotal: number;
+    analystsDone: number;
+    startedAt: string;
+  }>;
+  recentResearch: Array<{
+    sessionId: string;
+    workflow: string;
+    symbol?: string;
+    completedAt: string;
+  }>;
+  dataQuality: {
+    softGaps: Array<{ provider: string; lastSeen: string }>;
+    hardSkips: Array<{ provider: string; lastSeen: string }>;
+  };
+}
+
+export function createEmptyDashboardState(): DashboardState {
+  return {
+    watchlist: [],
+    activeAnalyses: [],
+    recentResearch: [],
+    dataQuality: { softGaps: [], hardSkips: [] },
+  };
+}
+
+export function projectDashboard(entries: SessionEntry[], sessionId = "local"): DashboardState {
+  const state = createEmptyDashboardState();
+
+  for (const entry of entries) {
+    if (entry.type === "message") {
+      projectMessage(state, entry.message as Message, entry.timestamp, sessionId);
+      continue;
+    }
+
+    if (entry.type === "custom" && entry.customType === "opencandle-workflow") {
+      const data = asRecord(entry.data);
+      const workflow = stringValue(data.workflow) ?? stringValue(data.workflowType) ?? "workflow";
+      const slots = asRecord(data.resolvedSlots);
+      const symbol = stringValue(slots.symbol) ?? firstString(slots.symbols);
+      state.activeAnalyses.push({
+        workflowId: stringValue(data.runId) ?? entry.id,
+        workflow,
+        symbol,
+        analystsTotal: numberValue(data.analystsTotal) ?? 0,
+        analystsDone: 0,
+        startedAt: entry.timestamp,
+      });
+      continue;
+    }
+
+    if (entry.type === "custom" && entry.customType === "opencandle-turn-gap") {
+      // The accumulator writes a single combined annotation string with one
+      // [OPENCANDLE_SKIPPED ... provider=X ...] tag per fallback provider.
+      // Older shapes may carry { softGaps: [...] } or { provider } directly —
+      // accept either to stay forward/backward compatible.
+      const data = asRecord(entry.data);
+      const annotation = stringValue(data.annotation);
+      if (annotation) {
+        for (const provider of parseSkippedProviders(annotation)) {
+          state.dataQuality.softGaps.push({ provider, lastSeen: entry.timestamp });
+        }
+      }
+      for (const gap of asArray(data.softGaps)) {
+        const provider = stringValue(asRecord(gap).provider);
+        if (provider) state.dataQuality.softGaps.push({ provider, lastSeen: entry.timestamp });
+      }
+      const provider = stringValue(data.provider);
+      if (provider) state.dataQuality.softGaps.push({ provider, lastSeen: entry.timestamp });
+    }
+
+    if (entry.type === "custom" && entry.customType === "opencandle-quote-refresh") {
+      const data = asRecord(entry.data);
+      projectQuote(
+        state,
+        stringValue(data.symbol),
+        asRecord(data.value),
+        asArray(data.content) as ToolResultMessage["content"],
+        entry.timestamp,
+      );
+    }
+  }
+
+  return state;
+}
+
+function projectMessage(
+  state: DashboardState,
+  message: Message,
+  timestamp: string,
+  sessionId: string,
+): void {
+  if (message.role === "toolResult") {
+    projectToolResult(state, message, timestamp);
+    return;
+  }
+
+  if (message.role === "assistant" && message.stopReason === "stop") {
+    const active = state.activeAnalyses.shift();
+    if (active) {
+      state.recentResearch.unshift({
+        sessionId,
+        workflow: active.workflow,
+        symbol: active.symbol,
+        completedAt: timestamp,
+      });
+    }
+  }
+}
+
+function projectToolResult(
+  state: DashboardState,
+  message: ToolResultMessage,
+  timestamp: string,
+): void {
+  if (message.toolName === "get_stock_quote") {
+    const rawDetails = asRecord(message.details);
+    const nestedValue = asRecord(rawDetails.value);
+    const details = Object.keys(nestedValue).length > 0 ? nestedValue : rawDetails;
+    projectQuote(state, stringValue(details.symbol), details, message.content, timestamp);
+  }
+
+  const text = message.content
+    .filter((part) => part.type === "text")
+    .map((part) => part.text)
+    .join("\n");
+  for (const provider of parseCredentialRequiredProviders(text)) {
+    state.dataQuality.hardSkips.push({ provider, lastSeen: timestamp });
+  }
+}
+
+function projectQuote(
+  state: DashboardState,
+  symbolHint: string | undefined,
+  details: Record<string, unknown>,
+  content: ToolResultMessage["content"],
+  timestamp: string,
+): void {
+  const symbol = symbolHint ?? inferSymbolFromContent(content);
+  if (!symbol) return;
+
+  const existing = state.watchlist.find((row) => row.symbol === symbol);
+  const row = {
+    symbol,
+    quote: Object.keys(details).length > 0 ? details : null,
+    pinned: existing?.pinned ?? false,
+    lastSeen: timestamp,
+  };
+  if (existing) Object.assign(existing, row);
+  else state.watchlist.push(row);
+}
+
+function parseCredentialRequiredProviders(text: string): string[] {
+  const providers: string[] = [];
+  const re = /\[OPENCANDLE_CREDENTIAL_REQUIRED[^\]]*provider=([a-z0-9_-]+)/gi;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(text)) !== null) {
+    providers.push(match[1]);
+  }
+  return providers;
+}
+
+function parseSkippedProviders(text: string): string[] {
+  const providers: string[] = [];
+  const re = /\[OPENCANDLE_SKIPPED[^\]]*provider=([a-z0-9_-]+)/gi;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(text)) !== null) {
+    providers.push(match[1]);
+  }
+  return providers;
+}
+
+function inferSymbolFromContent(content: ToolResultMessage["content"]): string | undefined {
+  const text = content.find((part) => part.type === "text")?.text;
+  const match = text?.match(/^([A-Z]{1,8})\b/);
+  return match?.[1];
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+function asArray(value: unknown): unknown[] {
+  return Array.isArray(value) ? value : [];
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function firstString(value: unknown): string | undefined {
+  return Array.isArray(value) ? value.find((item) => typeof item === "string") : undefined;
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === "number" ? value : undefined;
+}