wickchart 0.4.0 → 1.2.0

package/types/{hab-chart.d.ts → wick-chart.d.ts}

@@ -1,7 +1,7 @@
 declare const HTMLElementBase: {
     new (): {};
 };
-declare class HabChart extends HTMLElementBase {
+declare class WickChart extends HTMLElementBase {
     _canvas: any;
     _ctx: any;
     _legend: any;
@@ -142,6 +142,18 @@ declare class HabChart extends HTMLElementBase {
     _positions: any[];
     _alerts: any[];
     _seq: number;
+    _overlays: any[];
+    _scenario: {
+        path: {
+            h: number;
+            price: number;
+        }[];
+        horizon: number;
+        cone: boolean;
+        levels: number[];
+        color: string | null;
+        label: string;
+    };
     _onResize: () => void;
     _onPointerDown: (e: any) => void;
     _onPointerMove: (e: any) => void;
@@ -172,13 +184,93 @@ declare class HabChart extends HTMLElementBase {
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(name: any, _old: any, val: any): void;
-    static _registryMap: any;
-    /** Lazily-built registry, seeded with the built-in indicators. */
-    static _registry(): any;
+    /** Indicator registry (module scope — shared with the legacy alias tag). */
+    static _registry(): Map<string, {
+        kind: string;
+        params: {
+            period: number;
+            mult?: undefined;
+            fast?: undefined;
+            slow?: undefined;
+            signal?: undefined;
+        };
+        compute: (bars: any, p: any) => number[];
+        range?: undefined;
+        color?: undefined;
+        guides?: undefined;
+        fmt?: undefined;
+    } | {
+        kind: string;
+        params: {
+            period: number;
+            mult?: undefined;
+            fast?: undefined;
+            slow?: undefined;
+            signal?: undefined;
+        };
+        compute: (bars: any, p: any) => number[];
+        range?: undefined;
+        color?: undefined;
+        guides?: undefined;
+        fmt?: undefined;
+    } | {
+        kind: string;
+        params: {
+            period: number;
+            mult: number;
+            fast?: undefined;
+            slow?: undefined;
+            signal?: undefined;
+        };
+        compute: (bars: any, p: any) => {
+            lines: {
+                name: string;
+                values: number[];
+            }[];
+        };
+        range?: undefined;
+        color?: undefined;
+        guides?: undefined;
+        fmt?: undefined;
+    } | {
+        kind: string;
+        params: {
+            mult?: undefined;
+            period: number;
+            fast?: undefined;
+            slow?: undefined;
+            signal?: undefined;
+        };
+        guides: number[];
+        range: number[];
+        fmt: string;
+        color: string;
+        compute: (bars: any, p: any) => number[];
+    } | {
+        range?: undefined;
+        color?: undefined;
+        kind: string;
+        params: {
+            mult?: undefined;
+            period?: undefined;
+            fast: number;
+            slow: number;
+            signal: number;
+        };
+        guides: number[];
+        fmt: string;
+        compute: (bars: any, p: any) => {
+            lines: {
+                name: string;
+                values: number[];
+            }[];
+            histogram: number[];
+        };
+    }>;
     /**
      * Register a custom indicator.
      *
-     *   HabChart.registerIndicator('vwap', {
+     *   WickChart.registerIndicator('vwap', {
      *     kind: 'overlay',                    // or 'pane'
      *     params: { period: 20 },             // defaults; settable via name:period
      *     compute(bars, params) {             // bars: normalized {time,o,h,l,c,v}
@@ -269,22 +361,128 @@ declare class HabChart extends HTMLElementBase {
     removePosition(id: any): void;
     clearPositions(): void;
     /**
-     * Price alert. Fires `hab:alert` ({id, price, bar}) on an edge crossing
-     * during streaming updates.
-     * @param {{id?: string, price: number, direction?: 'above'|'below'|'cross',
-     *          once?: boolean}} alert
-     * @returns {string|null} the alert id
+     * Price or scripted alert. Price alerts fire `wick:alert`
+     * ({id, price, bar}) on an edge crossing; scripted alerts evaluate a
+     * WickScript predicate (`when`) on every streamed bar and fire on its
+     * false→true edge — e.g. `when: 'crossup(rsi(close,14), 30)'` or
+     * `when: 'volume > sma(volume,20) * 3'`. Scripted events carry the
+     * triggering close as `price` plus the `when` source (deprecated
+     * `hab:alert` alias still dispatched).
+     * @param {{id?: string, price?: number, direction?: 'above'|'below'|'cross',
+     *          when?: string, once?: boolean}} alert
+     * @returns {string|null} the alert id (null when no valid price/when,
+     *          or the predicate fails to compile)
      */
     addAlert(alert: {
         id?: string;
-        price: number;
+        price?: number;
         direction?: 'above' | 'below' | 'cross';
+        when?: string;
         once?: boolean;
     }): string | null;
     removeAlert(id: any): void;
     clearAlerts(): void;
-    /** Check alerts against an incoming bar (prev close → new close). */
+    /**
+     * Server-side overlays: zones & levels anchored in time × price — e.g.
+     * supply/demand zones from an analysis API. Zones with no `to` extend
+     * into future space past the last bar, like TradingView drawings.
+     *
+     *   zone:  { type:'zone', from?:ms, to?:ms|null, priceFrom, priceTo,
+     *            color?, alpha?, border?, label?, id? }
+     *   level: { type:'level', price, from?, to?, color?, width?, dash?,
+     *            label?, id? }
+     *
+     * Invalid entries are dropped, never thrown. Colors accept hex/rgb()/CSS
+     * names plus the palette keys 'up' | 'down' | 'accent'.
+     * @param {object[]} list
+     * @returns {string[]} applied overlay ids
+     */
+    setOverlays(list: object[]): string[];
+    /** @returns {object[]} a copy of the current overlays */
+    get overlays(): object[];
+    /**
+     * Add or replace (upsert, by id) a single overlay.
+     * @returns {string|null} the overlay id, or null if invalid
+     */
+    addOverlay(ov: any): string | null;
+    removeOverlay(id: any): void;
+    clearOverlays(): void;
+    /**
+     * Scenario projection into future space: a ghost path of future prices
+     * plus optional σ-bands (vol cone) from realized volatility.
+     *
+     *   chart.setScenario({ path: [64000, 65500, 68000], label: 'bull case' });
+     *   chart.setScenario({ horizon: 48, cone: true });   // cone-only
+     *
+     * The path is an array of prices (or {price} objects) for future bars
+     * 1..N; horizon defaults to the path length (1–500). `cone` (default
+     * true) draws ±levels·σ bands widening with √h from the current realized
+     * vol; `color` accepts up|down|accent or safe CSS colors. Setting a
+     * scenario reserves future space on the right; analysis data — excluded
+     * from getState/setState.
+     * @param {object} spec
+     * @returns {object|null} the normalized scenario, or null when invalid
+     */
+    setScenario(spec: object): object | null;
+    clearScenario(): void;
+    /** @returns {object|null} a copy of the active scenario */
+    get scenario(): object | null;
+    /** σ-cone for the active scenario, cached per data version. */
+    _scenarioConeCache(): any;
+    /** Tool manifest for LLM control — JSON-safe copy of AI_TOOLS. */
+    aiTools(): any;
+    /** System prompt for agent control — paste into any LLM alongside aiTools(). */
+    aiPrompt(): string;
+    /** Grounding context for a model: current state + visible-window summary. */
+    aiContext(): {
+        state: import("./core.js").ChartState;
+        window: object;
+    };
+    /**
+     * Apply a list of {tool, args} ops (typically LLM output) through the
+     * validated dispatcher in core. Never throws — each op resolves
+     * {ok, tool, result} or {ok: false, tool, error} so an agent can
+     * self-correct.
+     * @param {any} ops
+     * @returns {Array<object>}
+     */
+    applyAI(ops: any): Array<object>;
+    /**
+     * Ask an AI to operate the chart. Builds the payload {system,
+     * instruction, chart, tools}; with a `run` async function (your model
+     * call — the chart itself never touches the network), applies the
+     * returned ops and resolves {payload, ops, results}. Without `run`,
+     * returns the payload for manual wiring — send it anywhere, then call
+     * chart.applyAI(ops) with the model's answer.
+     *
+     *   const { results } = await chart.ask('add RSI and mark the demand zone', {
+     *     run: async (payload) => (await callMyLLM(payload)).ops,
+     *   });
+     *
+     * @param {string} instruction natural-language request
+     * @param {{run?: (payload: object) => Promise<any>}} [opts]
+     */
+    ask(instruction: string, opts?: {
+        run?: (payload: object) => Promise<any>;
+    }): Promise<{
+        payload: {
+            system: string;
+            instruction: string;
+            chart: {
+                state: import("./core.js").ChartState;
+                window: object;
+            };
+            tools: any;
+        };
+        ops: any;
+        results: object[];
+    }>;
+    /** Check alerts against an incoming bar (prev close → new close).
+     *  Scripted (`when`) alerts evaluate their predicate series, cached per
+     *  data version, and fire on the false→true edge. */
     _checkAlerts(prevClose: any, bar: any): void;
+    /** Cached boolean series for a scripted alert's predicate (per data version). */
+    _predicateCache(alert: any): any;
     get theme(): string;
     set theme(v: string);
     get type(): string;
@@ -386,6 +584,10 @@ declare class HabChart extends HTMLElementBase {
     _setupCoView(): void;
     _coviewSend(msg: any): void;
     _onCoMessage(m: any): void;
+    /** Dispatch `wick:name` (canonical) plus the deprecated `hab:name` alias,
+     *  so 0.x listeners keep working until 2.0. */
+    _fire(name: any, detail: any): void;
     _emitRange(): void;
 }
-export default HabChart;
+export default WickChart;
+export { WickChart };

package/types/{hab-feed.d.ts → wick-feed.d.ts}

@@ -1,8 +1,8 @@
-import './hab-chart.js';
+import './wick-chart.js';
 declare const HTMLElementBase: {
     new (): {};
 };
-declare class HabFeed extends HTMLElementBase {
+declare class WickFeed extends HTMLElementBase {
     _gen: number;
     _closers: any[];
     _timer: number;
@@ -15,7 +15,10 @@ declare class HabFeed extends HTMLElementBase {
     _scheduleRestart(): void;
     _teardown(): void;
     _setStatus(status: any, detail: any): void;
-    /** Resolve the target chart (by `for` id, else the first <hab-chart>). */
+    /** Dispatch `wick-feed:name` plus the deprecated `hab-feed:name` alias. */
+    _fire(name: any, detail: any): void;
+    /** Resolve the target chart (by `for` id, else the first chart element —
+     *  <wick-chart> or the deprecated <hab-chart>). */
     _resolveChart(): Element;
     _restart(): void;
     _synthetic(gen: any, chart: any, key: any, tfId: any, limit: any, live: any, status?: string): void;
@@ -24,4 +27,5 @@ declare class HabFeed extends HTMLElementBase {
     _degrade(gen: any, chart: any, sym: any, tfId: any, limit: any, live: any, err: any): void;
     _rest(gen: any, chart: any, url: any, limit: any, live: any): Promise<void>;
 }
-export default HabFeed;
+export default WickFeed;
+export { WickFeed };