opencandle 0.11.0 → 0.12.0

package/src/memory/storage.ts

@@ -1,195 +0,0 @@
-import type Database from "better-sqlite3";
-
-interface PreferenceInput {
-  namespace?: string;
-  key: string;
-  valueJson: string;
-  confidence?: string;
-  source?: string;
-}
-
-export interface WorkflowPreferences {
-  riskProfile?: string;
-  timeHorizon?: string;
-  assetScope?: string;
-  positionCount?: number;
-  maxSinglePositionPct?: number;
-  dteTarget?: string;
-  objective?: string;
-  moneynessPreference?: string;
-  liquidityMinimum?: string;
-}
-
-interface WorkflowRunInput {
-  sessionId: string;
-  workflowType: string;
-  inputSlotsJson: string;
-  resolvedSlotsJson: string;
-  defaultsUsedJson: string;
-  outputSummary?: string;
-  /**
-   * Router route verbatim. Legacy rows contain `"workflow"` or `"fallback"`;
-   * typed-router rows may contain canonical route kinds. Defaults to
-   * `"workflow"` at the schema layer so legacy callers (rules-mode cascade)
-   * don't need to pass anything. Router-mode callers MUST pass this explicitly.
-   */
-  turnType?: string;
-}
-
-interface RecommendationInput {
-  workflowRunId: number;
-  recommendationType: string;
-  symbol?: string;
-  payloadJson?: string;
-}
-
-export class MemoryStorage {
-  constructor(private readonly db: Database.Database) {}
-
-  // --- Preferences ---
-
-  upsertPreference(input: PreferenceInput): void {
-    const now = new Date().toISOString();
-    const ns = input.namespace ?? "global";
-    const confidence = input.confidence ?? "medium";
-    const source = input.source ?? "explicit";
-
-    this.db
-      .prepare(
-        `INSERT INTO user_preferences (namespace, key, value_json, confidence, source, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(namespace, key) DO UPDATE SET
-           value_json = excluded.value_json,
-           confidence = excluded.confidence,
-           source = excluded.source,
-           updated_at = excluded.updated_at`,
-      )
-      .run(ns, input.key, input.valueJson, confidence, source, now, now);
-  }
-
-  getPreference(namespace: string, key: string): Record<string, string | number | null> | null {
-    return (
-      (this.db
-        .prepare("SELECT * FROM user_preferences WHERE namespace = ? AND key = ?")
-        .get(namespace, key) as Record<string, string | number | null>) ?? null
-    );
-  }
-
-  getPreferencesByNamespace(namespace: string): Array<Record<string, string | number | null>> {
-    return this.db
-      .prepare("SELECT * FROM user_preferences WHERE namespace = ?")
-      .all(namespace) as Array<Record<string, string | number | null>>;
-  }
-
-  getWorkflowPreferences(namespace: string = "global"): WorkflowPreferences {
-    const prefs = this.getPreferencesByNamespace(namespace);
-    const out: WorkflowPreferences = {};
-
-    for (const pref of prefs) {
-      const key = String(pref.key);
-      const raw = pref.value_json == null ? undefined : safeParseJson(String(pref.value_json));
-
-      switch (key) {
-        case "risk_profile":
-          if (typeof raw === "string") out.riskProfile = raw;
-          break;
-        case "time_horizon":
-          if (typeof raw === "string") out.timeHorizon = raw;
-          break;
-        case "asset_scope":
-          if (typeof raw === "string") out.assetScope = raw;
-          break;
-        case "position_count":
-          if (typeof raw === "number") out.positionCount = raw;
-          break;
-        case "max_single_position_pct":
-          if (typeof raw === "number") out.maxSinglePositionPct = raw;
-          break;
-        case "dte_target":
-          if (typeof raw === "string") out.dteTarget = raw;
-          break;
-        case "objective":
-          if (typeof raw === "string") out.objective = raw;
-          break;
-        case "moneyness_preference":
-          if (typeof raw === "string") out.moneynessPreference = raw;
-          break;
-        case "options_liquidity":
-        case "liquidity_minimum":
-          if (typeof raw === "string") {
-            out.liquidityMinimum = raw === "high" ? "high_open_interest_and_tight_spread" : raw;
-          }
-          break;
-      }
-    }
-
-    return out;
-  }
-
-  // --- Workflow Runs ---
-
-  insertWorkflowRun(input: WorkflowRunInput): number {
-    const now = new Date().toISOString();
-    const result = this.db
-      .prepare(
-        `INSERT INTO workflow_runs (session_id, workflow_type, input_slots_json, resolved_slots_json, defaults_used_json, output_summary, created_at, turn_type)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-      )
-      .run(
-        input.sessionId,
-        input.workflowType,
-        input.inputSlotsJson,
-        input.resolvedSlotsJson,
-        input.defaultsUsedJson,
-        input.outputSummary ?? null,
-        now,
-        input.turnType ?? "workflow",
-      );
-    return Number(result.lastInsertRowid);
-  }
-
-  getRecentWorkflowRuns(limit: number): Array<Record<string, string | number | null>> {
-    return this.db
-      .prepare("SELECT * FROM workflow_runs ORDER BY id DESC LIMIT ?")
-      .all(limit) as Array<Record<string, string | number | null>>;
-  }
-
-  updateWorkflowRunOutputSummary(workflowRunId: number, outputSummary: string): void {
-    this.db
-      .prepare("UPDATE workflow_runs SET output_summary = ? WHERE id = ?")
-      .run(outputSummary, workflowRunId);
-  }
-
-  // --- Recommendations ---
-
-  insertRecommendation(input: RecommendationInput): number {
-    const now = new Date().toISOString();
-    const result = this.db
-      .prepare(
-        `INSERT INTO recommendations (workflow_run_id, recommendation_type, symbol, payload_json, created_at)
-         VALUES (?, ?, ?, ?, ?)`,
-      )
-      .run(
-        input.workflowRunId,
-        input.recommendationType,
-        input.symbol ?? null,
-        input.payloadJson ?? null,
-        now,
-      );
-    return Number(result.lastInsertRowid);
-  }
-
-  getRecommendationsByRun(workflowRunId: number): Array<Record<string, string | number | null>> {
-    return this.db
-      .prepare("SELECT * FROM recommendations WHERE workflow_run_id = ? ORDER BY id")
-      .all(workflowRunId) as Array<Record<string, string | number | null>>;
-  }
-}
-
-function safeParseJson(json: string): unknown {
-  try {
-    return JSON.parse(json);
-  } catch {
-    return json;
-  }
-}

package/src/memory/tool-defaults.ts

@@ -1,108 +0,0 @@
-import { initDefaultDatabase } from "./sqlite.js";
-
-export type ToolDefaults = Record<string, unknown>;
-type SqliteDb = ReturnType<typeof initDefaultDatabase>;
-
-export function getDefaults(toolName: string, db?: SqliteDb): ToolDefaults {
-  const ownedDb = db == null;
-  const connection = db ?? initDefaultDatabase();
-  try {
-    const rows = connection
-      .prepare(
-        `SELECT param_path, value_json FROM tool_defaults WHERE tool_name = ? ORDER BY param_path`,
-      )
-      .all(toolName) as Array<{ param_path: string; value_json: string }>;
-
-    const defaults: ToolDefaults = {};
-    for (const row of rows) {
-      setPath(defaults, row.param_path, parseStoredValue(row.value_json));
-    }
-    return defaults;
-  } finally {
-    if (ownedDb) connection.close();
-  }
-}
-
-export function getAllDefaults(db?: SqliteDb): Map<string, ToolDefaults> {
-  const ownedDb = db == null;
-  const connection = db ?? initDefaultDatabase();
-  try {
-    const rows = connection
-      .prepare(
-        `SELECT tool_name, param_path, value_json FROM tool_defaults ORDER BY tool_name, param_path`,
-      )
-      .all() as Array<{ tool_name: string; param_path: string; value_json: string }>;
-
-    const groups = new Map<string, ToolDefaults>();
-    for (const row of rows) {
-      const defaults = groups.get(row.tool_name) ?? {};
-      setPath(defaults, row.param_path, parseStoredValue(row.value_json));
-      groups.set(row.tool_name, defaults);
-    }
-    return groups;
-  } finally {
-    if (ownedDb) connection.close();
-  }
-}
-
-export function setDefault(
-  toolName: string,
-  paramPath: string,
-  value: unknown,
-  db?: SqliteDb,
-): void {
-  const ownedDb = db == null;
-  const connection = db ?? initDefaultDatabase();
-  try {
-    connection
-      .prepare(
-        `INSERT INTO tool_defaults (tool_name, param_path, value_json, set_at)
-       VALUES (?, ?, ?, ?)
-       ON CONFLICT(tool_name, param_path) DO UPDATE SET
-         value_json = excluded.value_json,
-         set_at = excluded.set_at`,
-      )
-      .run(toolName, paramPath, JSON.stringify(value), new Date().toISOString());
-  } finally {
-    if (ownedDb) connection.close();
-  }
-}
-
-export function clearDefault(toolName: string, paramPath: string, db?: SqliteDb): void {
-  const ownedDb = db == null;
-  const connection = db ?? initDefaultDatabase();
-  try {
-    connection
-      .prepare(`DELETE FROM tool_defaults WHERE tool_name = ? AND param_path = ?`)
-      .run(toolName, paramPath);
-  } finally {
-    if (ownedDb) connection.close();
-  }
-}
-
-function parseStoredValue(valueJson: string): unknown {
-  try {
-    return JSON.parse(valueJson);
-  } catch {
-    return valueJson;
-  }
-}
-
-function setPath(target: ToolDefaults, path: string, value: unknown): void {
-  const parts = path.split(".").filter(Boolean);
-  if (parts.length === 0) return;
-
-  let cursor: Record<string, unknown> = target;
-  for (const part of parts.slice(0, -1)) {
-    const existing = cursor[part];
-    if (!isPlainObject(existing)) {
-      cursor[part] = {};
-    }
-    cursor = cursor[part] as Record<string, unknown>;
-  }
-  cursor[parts[parts.length - 1]] = value;
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/memory/types.ts

@@ -1,71 +0,0 @@
-/** Memory categories for typed, selective retrieval. */
-export type MemoryCategory =
-  | "investor_profile"
-  | "interaction_feedback"
-  | "workflow_history"
-  | "references";
-
-/** A memory entry with category and freshness metadata. */
-export interface MemoryEntry {
-  key: string;
-  value: string;
-  category: MemoryCategory;
-  recordedAt: string;
-  confidence?: string;
-  source?: string;
-}
-
-/** Staleness thresholds in milliseconds per category. */
-export const STALENESS_THRESHOLDS: Record<MemoryCategory, number> = {
-  investor_profile: 90 * 24 * 60 * 60 * 1000, // 90 days
-  interaction_feedback: 14 * 24 * 60 * 60 * 1000, // 14 days
-  workflow_history: 7 * 24 * 60 * 60 * 1000, // 7 days
-  references: 30 * 24 * 60 * 60 * 1000, // 30 days
-};
-
-/** Map preference keys to memory categories. */
-export const KEY_TO_CATEGORY: Record<string, MemoryCategory> = {
-  risk_profile: "investor_profile",
-  time_horizon: "investor_profile",
-  asset_scope: "investor_profile",
-  position_count: "investor_profile",
-  max_single_position_pct: "investor_profile",
-  account_type: "investor_profile",
-  income_vs_growth: "investor_profile",
-  dte_target: "investor_profile",
-  objective: "investor_profile",
-  moneyness_preference: "investor_profile",
-  liquidity_minimum: "investor_profile",
-};
-
-/** Categories relevant to each workflow type. */
-export const WORKFLOW_RELEVANT_CATEGORIES: Record<string, MemoryCategory[]> = {
-  portfolio_builder: ["investor_profile", "interaction_feedback", "workflow_history"],
-  options_screener: ["investor_profile", "interaction_feedback", "workflow_history"],
-  compare_assets: ["investor_profile", "workflow_history"],
-  comprehensive_analysis: ["investor_profile", "workflow_history"],
-  single_asset_analysis: ["investor_profile"],
-  general_finance_qa: ["investor_profile"],
-  workflow_dispatch: ["investor_profile", "workflow_history"],
-  agent_task: ["investor_profile", "workflow_history"],
-  clarification: ["investor_profile", "workflow_history"],
-  pass_through: [],
-  unclassified: ["investor_profile"],
-};
-
-/** Check whether a memory entry is stale. */
-export function isStale(entry: MemoryEntry, now: Date = new Date()): boolean {
-  const threshold = STALENESS_THRESHOLDS[entry.category];
-  const age = now.getTime() - new Date(entry.recordedAt).getTime();
-  return age > threshold;
-}
-
-/** Keys whose values are market-sensitive and must never be trusted from memory. */
-export const NEVER_TRUST_FROM_MEMORY = new Set([
-  "stock_price",
-  "crypto_price",
-  "market_thesis",
-  "target_price",
-  "entry_price",
-  "stop_loss",
-]);

package/src/monitor.ts

@@ -1,123 +0,0 @@
-#!/usr/bin/env node
-import { parseArgs } from "node:util";
-import { loadEnv } from "./config.js";
-import { assertSupportedNodeVersion } from "./infra/node-version.js";
-import { runLocalAutomationHeartbeat } from "./market-state/local-automation-service.js";
-import { MarketStateService } from "./market-state/service.js";
-import { initDefaultDatabase } from "./memory/sqlite.js";
-
-assertSupportedNodeVersion();
-
-const DEFAULT_MONITOR_INTERVAL_MS = 60_000;
-const MIN_MONITOR_INTERVAL_MS = 5_000;
-const MONITOR_OWNER_ID = `monitor:${process.pid}`;
-
-interface MonitorOptions {
-  once: boolean;
-  intervalMs: number;
-}
-
-function parseMonitorOptions(argv = process.argv.slice(2)): MonitorOptions {
-  const parsed = parseArgs({
-    args: argv,
-    options: {
-      once: { type: "boolean", default: false },
-      "interval-ms": { type: "string" },
-    },
-    strict: false,
-  });
-  return {
-    once: parsed.values.once === true,
-    intervalMs: normalizeMonitorIntervalMs(parsed.values["interval-ms"]),
-  };
-}
-
-function normalizeMonitorIntervalMs(raw: string | boolean | undefined): number {
-  if (typeof raw !== "string" || raw.trim() === "") return DEFAULT_MONITOR_INTERVAL_MS;
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed < MIN_MONITOR_INTERVAL_MS)
-    return DEFAULT_MONITOR_INTERVAL_MS;
-  return Math.floor(parsed);
-}
-
-async function runMonitorHeartbeat(
-  intervalMs: number,
-  releaseLeaseOnComplete = false,
-): Promise<void> {
-  const db = initDefaultDatabase();
-  const now = new Date().toISOString();
-  try {
-    const result = await runLocalAutomationHeartbeat(db, {
-      ownerId: MONITOR_OWNER_ID,
-      ownerKind: "monitor",
-      now,
-      ttlSeconds: Math.max(90, Math.ceil((intervalMs * 2) / 1000)),
-      checkAlerts: true,
-      checkReports: true,
-      releaseLeaseOnComplete,
-    });
-    if (!result.lease.acquired) {
-      console.log(
-        `OpenCandle monitor standby: runner owned by ${result.lease.ownerId} until ${result.lease.expiresAt}`,
-      );
-      return;
-    }
-    const alertSummary = result.alertCheck
-      ? `${result.alertCheck.checked} alert(s), ${result.alertCheck.triggered} triggered, ${result.alertCheck.unavailable} unavailable`
-      : "no due alerts";
-    const reportSummary = result.reportRuns.length
-      ? `${result.reportRuns.length} report run(s)`
-      : "no due reports";
-    console.log(`OpenCandle monitor heartbeat ${now}: ${alertSummary}; ${reportSummary}.`);
-  } finally {
-    db.close();
-  }
-}
-
-async function main(): Promise<void> {
-  loadEnv();
-  const options = parseMonitorOptions();
-  let inFlight = false;
-  const runOnce = async (): Promise<void> => {
-    if (inFlight) {
-      console.log("OpenCandle monitor heartbeat skipped: previous run is still active.");
-      return;
-    }
-    inFlight = true;
-    try {
-      await runMonitorHeartbeat(options.intervalMs, options.once);
-    } finally {
-      inFlight = false;
-    }
-  };
-
-  await runOnce();
-  if (options.once) return;
-
-  console.log(
-    `OpenCandle monitor running locally every ${options.intervalMs}ms. Keep this process open for local alerts and reports.`,
-  );
-  const timer = setInterval(() => {
-    void runOnce().catch((error) => {
-      console.error(
-        `OpenCandle monitor heartbeat failed: ${error instanceof Error ? error.message : String(error)}`,
-      );
-    });
-  }, options.intervalMs);
-
-  const stop = () => {
-    clearInterval(timer);
-    const db = initDefaultDatabase();
-    try {
-      new MarketStateService(db).releaseAutomationRunnerLease(MONITOR_OWNER_ID);
-    } finally {
-      db.close();
-    }
-    console.log("OpenCandle monitor stopped.");
-    process.exit(0);
-  };
-  process.once("SIGINT", stop);
-  process.once("SIGTERM", stop);
-}
-
-await main();

package/src/onboarding/connect.ts

@@ -1,177 +0,0 @@
-// Shared `runProviderConnect` function — the actual side-effectful flow that
-// opens a browser, collects a pasted API key, validates it against the
-// provider's API, persists it to `~/.opencandle/config.json`, and refreshes
-// the cached Config so the next tool call sees the new credential.
-//
-// Called from two places:
-//   1. The Pi `tool_result` extension handler when the user picks "Connect now"
-//      in the just-in-time prompt (Task Group 10).
-//   2. The `/connect` Pi command (Task Group 13).
-//
-// Validation (Task Group 8 final pass): before persisting, the pasted key is
-// validated via `validateCredential`, which makes a single cheap request to
-// the provider's canonical API and classifies the response. A hard
-// auth failure (401/403 or a provider-specific error-in-200-body) is
-// returned as `invalid_key` WITHOUT persisting the bad value; a transient
-// failure (timeout, 5xx, network error) warns the user but still persists
-// the key so they aren't blocked on a provider outage — the next real tool
-// call will surface any lingering issue via the credential-required tag.
-
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-  loadConfig,
-  loadFileConfig,
-  type OpenCandleFileConfig,
-  saveFileConfig,
-} from "../config.js";
-import { openInBrowser } from "../infra/open-url.js";
-import {
-  type ApiKeyProviderId,
-  getCredentialSource,
-  getProvider,
-  isApiKeyProvider,
-  type ProviderId,
-} from "./providers.js";
-import { loadOnboardingState, markProviderCompleted, saveOnboardingState } from "./state.js";
-import { validateCredential } from "./validation.js";
-
-export type ConnectResult =
-  | { status: "connected" }
-  | { status: "cancelled" }
-  | { status: "blocked_by_env" }
-  | { status: "invalid_key"; httpStatus?: number; message?: string };
-
-function writeNested(
-  obj: Record<string, unknown>,
-  path: readonly string[],
-  value: string,
-): Record<string, unknown> {
-  if (path.length === 0) return obj;
-  const [head, ...rest] = path;
-  const next = { ...obj };
-  if (rest.length === 0) {
-    next[head] = value;
-  } else {
-    const child =
-      next[head] && typeof next[head] === "object" ? (next[head] as Record<string, unknown>) : {};
-    next[head] = writeNested(child, rest, value);
-  }
-  return next;
-}
-
-/**
- * Persist an already-validated provider credential.
- *
- * Writes the key into `~/.opencandle/config.json` (preserving sibling fields),
- * refreshes the cached `Config` so the next tool call sees the new value, and
- * marks the provider as completed in the onboarding state.
- *
- * Shared by the TUI `/connect` flow (`runProviderConnect`) and the GUI
- * provider-setup form. Validation is the caller's responsibility — both
- * call sites run `validateCredential` before invoking this helper.
- */
-export function persistProviderCredential(providerId: ApiKeyProviderId, key: string): void {
-  const descriptor = getProvider(providerId);
-  if (!isApiKeyProvider(descriptor)) {
-    throw new Error(`Provider ${providerId} does not accept API keys`);
-  }
-  const existing = loadFileConfig() as unknown as Record<string, unknown>;
-  const updated = writeNested(existing, descriptor.configPath, key) as OpenCandleFileConfig;
-  saveFileConfig(updated);
-  loadConfig();
-  const state = loadOnboardingState();
-  saveOnboardingState(markProviderCompleted(state, providerId));
-}
-
-/**
- * Run the connect flow for a single provider.
- *
- * Env-precedence short-circuit: if the provider's configured credential
- * already comes from an environment variable, the file-config write would
- * be invisible to the next tool call (env vars win in `resolveConfig`).
- * Notify the user explicitly and return `blocked_by_env` — do not open
- * the browser or collect a pasted value.
- */
-export async function runProviderConnect(
-  ctx: ExtensionContext,
-  providerId: ProviderId,
-): Promise<ConnectResult> {
-  const descriptor = getProvider(providerId);
-  if (!isApiKeyProvider(descriptor)) {
-    ctx.ui.notify(
-      `${descriptor.displayName} is not configured with an API key. Run opencandle doctor for setup status.`,
-      "warning",
-    );
-    return { status: "cancelled" };
-  }
-
-  // Env-precedence check.
-  if (getCredentialSource(providerId) === "env") {
-    ctx.ui.notify(
-      `${descriptor.displayName} is currently set via the ${descriptor.envVar} environment variable. ` +
-        `To change it from here, unset that variable first and reopen /connect ${descriptor.aliases[0] ?? descriptor.id}. ` +
-        `Otherwise, update ${descriptor.envVar} directly in your shell profile.`,
-      "warning",
-    );
-    return { status: "blocked_by_env" };
-  }
-
-  // Open the signup URL in the user's browser. We ignore errors here — if
-  // the browser can't be opened, the user can still paste a key they
-  // already have, so we continue rather than bailing.
-  await openInBrowser(descriptor.signupUrl).catch(() => {});
-  ctx.ui.notify(`Opening ${descriptor.displayName} signup in your browser...`, "info");
-
-  // Prompt for the key. Uses the provider's instructionsHint as the
-  // placeholder text to remind the user what they're pasting.
-  const pasted = await ctx.ui.input(
-    `Paste your ${descriptor.displayName} API key`,
-    descriptor.instructionsHint,
-  );
-  if (!pasted) {
-    return { status: "cancelled" };
-  }
-  const trimmed = pasted.trim();
-  if (trimmed.length === 0) {
-    return { status: "cancelled" };
-  }
-
-  // Validate the key with the provider BEFORE persisting. Hard auth failures
-  // short-circuit here without writing anything; transient failures warn
-  // but proceed to persist so users don't get stuck on a provider outage.
-  ctx.ui.notify(`Verifying your ${descriptor.displayName} key...`, "info");
-  const validation = await validateCredential(descriptor.id, trimmed);
-
-  if (validation.status === "invalid") {
-    const statusHint =
-      validation.httpStatus !== undefined ? ` (HTTP ${validation.httpStatus})` : "";
-    const messageHint = validation.message ? ` — ${validation.message}` : "";
-    ctx.ui.notify(
-      `${descriptor.displayName} rejected the key${statusHint}${messageHint}. ` +
-        `Your existing configuration was not changed. Re-run /connect ${
-          descriptor.aliases[0] ?? descriptor.id
-        } to try a different key.`,
-      "error",
-    );
-    return {
-      status: "invalid_key",
-      httpStatus: validation.httpStatus,
-      message: validation.message,
-    };
-  }
-
-  if (validation.status === "transient") {
-    ctx.ui.notify(
-      `Couldn't reach ${descriptor.displayName} to verify the key (${validation.reason}). ` +
-        `Saving it anyway — the next request will surface any issue.`,
-      "warning",
-    );
-    // Fall through to persist.
-  }
-
-  persistProviderCredential(descriptor.id, trimmed);
-
-  ctx.ui.notify(`${descriptor.displayName} connected. Your key has been saved.`, "info");
-
-  return { status: "connected" };
-}