@363045841yyt/klinechart-core 0.8.1 → 0.8.3

package/src/data-fetchers/thousand-mock.ts

@@ -1,30 +1,63 @@
-import type { DataFetcher, KLineData } from '../controllers/types'
+import type { KLineData } from '../controllers/types'
+import { DataFetcher } from './fetcherDefinitionRegistry'
+import type { FetchConfig } from './types'
 
-export const thousandMockDataFetcher: DataFetcher = async (_source, _config) => {
+async function fetchThousandMock(
+  _source: string,
+  _config: FetchConfig,
+): Promise<ReadonlyArray<KLineData>> {
   console.log('[thousand-mock] generating 10k K-lines')
   const data: KLineData[] = []
   const startTime = new Date('2020-01-01').getTime()
   const dayMs = 24 * 60 * 60 * 1000
-  let lastClose = 3000
-  for (let i = 0; i < 10000; i++) {
+  const totalDays = 10000
+
+  const basePrice = 3000
+  const meanReversionStrength = 0.0005
+  const volatility = 0.02
+
+  const rawWalk: number[] = [basePrice]
+  for (let i = 1; i < totalDays; i++) {
+    const prev = rawWalk[i - 1]!
+    const reversion = meanReversionStrength * (basePrice - prev)
+    const change = (Math.random() - 0.5) * 2 * volatility * prev + reversion
+    rawWalk.push(prev + change)
+  }
+
+  const finalOffset = rawWalk[totalDays - 1]! - basePrice
+  for (let i = 0; i < totalDays; i++) {
+    const bridge = finalOffset * (i / (totalDays - 1))
+    const close = Math.round((rawWalk[i]! - bridge) * 100) / 100
+
     const timestamp = startTime + i * dayMs
-    const volatility = 0.02
-    const trend = 0.0001
-    const change = (Math.random() - 0.5) * 2 * volatility + trend
-    const open = lastClose
-    const close = open * (1 + change)
-    const high = Math.max(open, close) * (1 + Math.random() * 0.01)
-    const low = Math.min(open, close) * (1 - Math.random() * 0.01)
+    const open = i === 0 ? basePrice : data[i - 1]!.close
+
+    const high = Math.round(Math.max(open, close) * (1 + Math.random() * 0.01) * 100) / 100
+    const low = Math.round(Math.min(open, close) * (1 - Math.random() * 0.01) * 100) / 100
     const volume = Math.floor(1000000 + Math.random() * 5000000)
     data.push({
       timestamp,
-      open: parseFloat(open.toFixed(2)),
-      high: parseFloat(high.toFixed(2)),
-      low: parseFloat(low.toFixed(2)),
-      close: parseFloat(close.toFixed(2)),
+      open,
+      high,
+      low,
+      close,
       volume,
     })
-    lastClose = close
   }
+
   return data
 }
+
+@DataFetcher({
+  name: 'mock-10000',
+  displayName: 'Mock 10000',
+  description: 'Generates ~10,000 random K-line bars with Brownian bridge',
+  version: '1.0.0',
+  capabilities: ['*'],
+})
+export class ThousandMockFetcher {
+  static fetcher = fetchThousandMock
+}
+
+/** @deprecated Use `ThousandMockFetcher.fetcher` directly or rely on routerDataFetcher. */
+export const thousandMockDataFetcher = fetchThousandMock

package/src/data-fetchers/tradingview.ts

@@ -1,4 +1,6 @@
-import type { DataFetcher, KLineData } from '../controllers/types'
+import type { KLineData } from '../controllers/types'
+import { DataFetcher } from './fetcherDefinitionRegistry'
+import type { FetchConfig } from './types'
 
 const PERIOD_TO_TIMEFRAME: Record<string, string> = {
   daily: '1d',
@@ -10,14 +12,25 @@ const PERIOD_TO_TIMEFRAME: Record<string, string> = {
   '60min': '60m',
 }
 
-export const tradingviewDataFetcher: DataFetcher = async (source, config) => {
-  const baseUrl = source === 'tradingview' ? 'http://localhost:8000' : ''
+const ADJUST_TO_TV: Record<string, string | undefined> = {
+  qfq: 'dividends',
+  splits: 'splits',
+  none: 'none',
+}
+
+const BASE_URL = 'http://localhost:8000'
+
+async function fetchTradingview(
+  _source: string,
+  config: FetchConfig,
+): Promise<ReadonlyArray<KLineData>> {
   const timeframe = PERIOD_TO_TIMEFRAME[config.period] ?? '1d'
   const startDate = config.startDate.split('T')[0]
   const endDate = config.endDate.split('T')[0]
-
+  const tvAdjust = ADJUST_TO_TV[config.adjust]
   const exchangeQ = config.exchange ? `&exchange=${config.exchange}` : ''
-  const url = `${baseUrl}/api/tradingview/kdata?symbol=${config.symbol}&timeframe=${timeframe}&start_date=${startDate}&end_date=${endDate}${exchangeQ}`
+  const adjustQ = tvAdjust ? `&adjust=${tvAdjust}` : ''
+  const url = `${BASE_URL}/api/tradingview/kdata?symbol=${config.symbol}&timeframe=${timeframe}&start_date=${startDate}&end_date=${endDate}${exchangeQ}${adjustQ}`
   try {
     const res = await fetch(url)
     if (!res.ok) {
@@ -30,7 +43,6 @@ export const tradingviewDataFetcher: DataFetcher = async (source, config) => {
     if (json.warning) {
       console.warn(`[tradingview] ${json.warning}`)
     }
-
     return (json.data ?? []).map((item: Record<string, unknown>) => ({
       timestamp: item.ts_open as number,
       date: item.date as string,
@@ -46,3 +58,17 @@ export const tradingviewDataFetcher: DataFetcher = async (source, config) => {
     throw err
   }
 }
+
+@DataFetcher({
+  name: 'tradingview',
+  displayName: 'TradingView',
+  description: 'TradingView-style data source via local proxy',
+  version: '1.0.0',
+  capabilities: ['daily', 'weekly', 'monthly', '5min', '15min', '30min', '60min'],
+})
+export class TradingviewFetcher {
+  static fetcher = fetchTradingview
+}
+
+/** @deprecated Use `TradingviewFetcher.fetcher` directly or rely on routerDataFetcher. */
+export const tradingviewDataFetcher = fetchTradingview

package/src/data-fetchers/types.ts

@@ -0,0 +1,27 @@
+import type { KLineData } from '../controllers/types'
+
+export type FetchConfig = {
+  symbol: string
+  startDate: string
+  endDate: string
+  period: string
+  adjust: string
+  exchange?: string
+}
+
+export type DataFetcherFn = (
+  source: string,
+  config: FetchConfig,
+) => Promise<ReadonlyArray<KLineData>>
+
+export interface DataFetcherDefinitionConfig {
+  name: string
+  displayName: string
+  description?: string
+  version?: string
+  capabilities?: string[]
+}
+
+export interface DataFetcherDefinition extends DataFetcherDefinitionConfig {
+  fetcher: DataFetcherFn
+}

package/src/engine/data/chartDataManager.ts

@@ -177,6 +177,10 @@ export class ChartDataManager {
     return this._symbolsSignal
   }
 
+  get currentPeriod(): string {
+    return this._dataBuffer.currentSpec?.period ?? 'daily'
+  }
+
   getInternalData(): KLineData[] {
     return this._internalData
   }

package/src/engine/render/chartRenderer.ts

@@ -401,6 +401,7 @@ export class ChartRenderer {
         overlayCtx: overlayCtx ?? undefined,
         pane: wrapPaneInfo(pane),
         data: dataManager.getInternalData(),
+        period: dataManager.currentPeriod,
         comparisonData: dataManager.getComparisonData(),
         comparisonSymbols: dataManager.getComparisonSpecs(),
         comparisonColors: dataManager.getComparisonColors(),
@@ -496,6 +497,7 @@ export class ChartRenderer {
           },
           priceRange: { maxPrice: 0, minPrice: 0 },
         },
+        period: this.deps.getDataManager().currentPeriod,
         data: this.deps.getDataManager().getInternalData(),
         range,
         scrollLeft: vp.scrollLeft,

package/src/engine/renderers/Indicator/ichimoku.ts

@@ -1,5 +1,6 @@
 import type { RendererPluginWithHost, RenderContext, PluginHost } from '../../../plugin'
 import { RENDERER_PRIORITY } from '../../../plugin'
+import { resolveThemeColors } from '../../../tokens'
 import type { KLineData } from '../../../types/price'
 import type { IchimokuRenderState } from '../../indicators/ichimokuState'
 import { createIchimokuStateKey, EMPTY_ICHIMOKU_STATE } from '../../indicators/ichimokuState'
@@ -14,8 +15,6 @@ const KIJUN_COLOR = '#2563eb'
 const SPAN_A_COLOR = '#16a34a'
 const SPAN_B_COLOR = '#dc2626'
 const CHIKOU_COLOR = '#7c3aed'
-const CLOUD_BULL = 'rgba(34, 197, 94, 0.15)'
-const CLOUD_BEAR = 'rgba(239, 68, 68, 0.15)'
 
 type Point = { x: number; y: number }
 
@@ -58,6 +57,7 @@ export function createIchimokuRendererPlugin(options: IchimokuRendererOptions =
 
         draw(context: RenderContext) {
             const { ctx, pane, range, scrollLeft, kLineCenters, lineWebGLSurface } = context
+            const colors = resolveThemeColors(context.theme, context.isAsiaMarket, context.colorPresetSettings)
             const stateKey = resolveKey()
             if (!stateKey) return
             const state = pluginHost?.getSharedState<IchimokuRenderState>(stateKey)
@@ -94,7 +94,7 @@ export function createIchimokuRendererPlugin(options: IchimokuRendererOptions =
             if (params.showCloud && cloudSegs.length >= 2) {
                 ctx.save()
                 ctx.translate(-scrollLeft, 0)
-                fillCloud(ctx, cloudSegs)
+                fillCloud(ctx, cloudSegs, colors.candleUpBody, colors.candleDownBody)
                 ctx.restore()
             }
 
@@ -153,11 +153,16 @@ function drawLine(ctx: CanvasRenderingContext2D, pts: Point[], color: string): v
 function fillCloud(
     ctx: CanvasRenderingContext2D,
     segs: { x: number; ya: number; yb: number; bull: boolean }[],
+    bullColor: string,
+    bearColor: string,
+    alpha = 0.15,
 ): void {
+    ctx.save()
+    ctx.globalAlpha = alpha
     for (let i = 0; i < segs.length - 1; i++) {
         const a = segs[i]!
         const b = segs[i + 1]!
-        ctx.fillStyle = a.bull ? CLOUD_BULL : CLOUD_BEAR
+        ctx.fillStyle = a.bull ? bullColor : bearColor
         ctx.beginPath()
         ctx.moveTo(a.x, a.ya)
         ctx.lineTo(b.x, b.ya)
@@ -166,6 +171,7 @@ function fillCloud(
         ctx.closePath()
         ctx.fill()
     }
+    ctx.restore()
 }
 
 export function getIchimokuTitleInfo(

package/src/engine/renderers/Indicator/mainIndicatorLegend.ts

@@ -218,7 +218,7 @@ function pushComparisonLegendRows(
         const sign = pct > 0 ? '+' : ''
         const pctText = `${sign}${pct.toFixed(2)}%`
         overlayCtx.fillStyle = pct > 0 ? colors.candleUpBody : pct < 0 ? colors.candleDownBody : colors.text.primary
-        overlayCtx.fillText(pctText, x, y + 1)
+        overlayCtx.fillText(pctText, x, y)
       },
     })
   }

package/src/engine/renderers/Indicator/sar.ts

@@ -1,5 +1,6 @@
 import type { RendererPluginWithHost, RenderContext, PluginHost } from '../../../plugin'
 import { RENDERER_PRIORITY } from '../../../plugin'
+import { resolveThemeColors } from '../../../tokens'
 import type { KLineData } from '../../../types/price'
 import type { SARRenderState } from '../../indicators/sarState'
 import { createSARStateKey, EMPTY_SAR_STATE } from '../../indicators/sarState'
@@ -9,8 +10,6 @@ import type { IndicatorScheduler, SARSchedulerConfig } from '../../indicators/sc
 import { calcSARData } from '../../indicators/calculators'
 import { createValuePointVisibleStateComposer } from '../../indicators/visibleStateComposers'
 
-const SAR_UP_COLOR = '#22c55e'
-const SAR_DOWN_COLOR = '#ef4444'
 const DOT_RADIUS = 1.5
 const TAU = Math.PI * 2
 
@@ -59,6 +58,7 @@ export function createSARRendererPlugin(options: SARRendererOptions = {}): Rende
 
         draw(context: RenderContext) {
             const { ctx, pane, range, scrollLeft, kLineCenters } = context
+            const colors = resolveThemeColors(context.theme, context.isAsiaMarket, context.colorPresetSettings)
 
             const stateKey = resolveKey()
             if (!stateKey) return
@@ -77,7 +77,7 @@ export function createSARRendererPlugin(options: SARRendererOptions = {}): Rende
                 const centerX = kLineCenters[i - range.start]
                 if (centerX === undefined) continue
                 const y = pane.yAxis.priceToY(point.value)
-                ctx.fillStyle = point.trend === 'up' ? SAR_UP_COLOR : SAR_DOWN_COLOR
+                ctx.fillStyle = point.trend === 'up' ? colors.candleUpBody : colors.candleDownBody
                 ctx.beginPath()
                 ctx.arc(centerX, y, DOT_RADIUS, 0, TAU)
                 ctx.fill()

package/src/engine/renderers/Indicator/supertrend.ts

@@ -1,5 +1,6 @@
 import type { RendererPluginWithHost, RenderContext, PluginHost } from '../../../plugin'
 import { RENDERER_PRIORITY } from '../../../plugin'
+import { resolveThemeColors } from '../../../tokens'
 import type { KLineData } from '../../../types/price'
 import type { SuperTrendRenderState } from '../../indicators/supertrendState'
 import { createSuperTrendStateKey, EMPTY_SUPERTREND_STATE } from '../../indicators/supertrendState'
@@ -9,9 +10,6 @@ import type { IndicatorScheduler, SuperTrendSchedulerConfig } from '../../indica
 import { calcSuperTrendData } from '../../indicators/calculators'
 import { createValuePointVisibleStateComposer } from '../../indicators/visibleStateComposers'
 
-const ST_UP_COLOR = '#22c55e'
-const ST_DOWN_COLOR = '#ef4444'
-
 export interface SuperTrendRendererOptions {
     paneId?: string
 }
@@ -51,6 +49,7 @@ export function createSuperTrendRendererPlugin(options: SuperTrendRendererOption
 
         draw(context: RenderContext) {
             const { ctx, pane, range, scrollLeft, kLineCenters } = context
+            const colors = resolveThemeColors(context.theme, context.isAsiaMarket, context.colorPresetSettings)
             const stateKey = resolveKey()
             if (!stateKey) return
             const state = pluginHost?.getSharedState<SuperTrendRenderState>(stateKey)
@@ -77,7 +76,7 @@ export function createSuperTrendRendererPlugin(options: SuperTrendRendererOption
                 const y = pane.yAxis.priceToY(point.value)
 
                 if (prevX !== null && prevTrend === point.trend) {
-                    ctx.strokeStyle = point.trend === 'up' ? ST_UP_COLOR : ST_DOWN_COLOR
+                    ctx.strokeStyle = point.trend === 'up' ? colors.candleUpBody : colors.candleDownBody
                     ctx.beginPath()
                     ctx.moveTo(prevX, prevY!)
                     ctx.lineTo(centerX, y)

package/src/engine/renderers/__tests__/boll.renderer.test.ts

@@ -118,6 +118,7 @@ function createMockRenderContext(
     scrollLeft: 0,
     pane: mockPane,
     kLineCenters: Array.from({ length: 100 }, (_, i) => i * 10 + 5),
+    period: 'daily',
     ...overrides,
   } as RenderContext
 }

package/src/engine/renderers/__tests__/ene.renderer.test.ts

@@ -106,6 +106,7 @@ function createMockRenderContext(
     scrollLeft: 0,
     pane: mockPane,
     kLineCenters: Array.from({ length: 100 }, (_, i) => i * 10 + 5),
+    period: 'daily',
     ...overrides,
   } as RenderContext
 }

package/src/engine/renderers/__tests__/expma.renderer.test.ts

@@ -105,6 +105,7 @@ function createMockRenderContext(
     scrollLeft: 0,
     pane: mockPane,
     kLineCenters: Array.from({ length: 100 }, (_, i) => i * 10 + 5),
+    period: 'daily',
     ...overrides,
   } as RenderContext
 }

package/src/engine/renderers/__tests__/ma.renderer.test.ts

@@ -104,6 +104,7 @@ function createMockRenderContext(
     scrollLeft: 0,
     pane: mockPane,
     kLineCenters: Array.from({ length: 10 }, (_, i) => i * 10 + 5),
+    period: 'daily',
     ...overrides,
   } as RenderContext
 }

package/src/engine/renderers/__tests__/mainIndicatorLegend.renderer.test.ts

@@ -168,6 +168,7 @@ function createMockRenderContext(
     scrollLeft: 0,
     pane: mockPane,
     kLineCenters: Array.from({ length: 100 }, (_, i) => i * 10 + 5),
+    period: 'daily',
     ...overrides,
   } as RenderContext
 }

package/src/engine/renderers/__tests__/yAxis.renderer.test.ts

@@ -76,6 +76,7 @@ function createContext(overrides: Partial<RenderContext> = {}): RenderContext {
     kBarRects: [] as { x: number; width: number }[],
     yAxisLabels: [],
     xAxisLabels: [],
+    period: 'daily',
     theme: 'light',
     ...overrides,
   }

package/src/engine/renderers/timeAxis.ts

@@ -56,6 +56,7 @@ export function createTimeAxisRendererPlugin(options: {
         lineColor: colors.border.dark,
         drawTopBorder: false,
         drawBottomBorder: false,
+        period: context.period,
       }, context.theme, context.isAsiaMarket, context.colorPresetSettings)
 
       // 绘制来自 xAxisRanges 的时间范围带（先于标签绘制）

package/src/index.ts

@@ -1,4 +1,6 @@
 export * from './reactivity'
 export * from './controllers'
+export * from './mcp'
 export { VERSION } from './version'
 export * from './tokens'
+export { formatTimestamp } from './utils/dateFormat'

package/src/mcp/chartBridge.ts

@@ -0,0 +1,220 @@
+import type { ToolCall, ToolResult, ControllerDescription, ToolCallHandler } from './types'
+
+export interface ChartBridgeOptions {
+  wsUrl: string
+  onToolCall: ToolCallHandler
+  sessionId?: string
+  autoReconnect?: boolean
+  reconnectDelay?: number
+  heartbeatInterval?: number
+  wsImpl?: new (url: string) => WebSocket
+}
+
+export type ChartBridgeEvent =
+  | 'connected'
+  | 'disconnected'
+  | 'error'
+  | 'stateChanged'
+
+type MessageHandler = (...args: unknown[]) => void
+
+export class ChartBridge {
+  readonly sessionId: string
+  private readonly autoReconnect: boolean
+  private readonly reconnectDelay: number
+  private readonly heartbeatInterval: number
+  private readonly onToolCall: ToolCallHandler
+
+  private readonly wsImpl: new (url: string) => WebSocket
+  private ws: WebSocket | null = null
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null
+  private destroyed = false
+
+  private listeners = new Map<ChartBridgeEvent, Set<MessageHandler>>()
+
+  onConnected?: () => void
+  onDisconnected?: () => void
+  onError?: (err: Error) => void
+  onStateChange?: () => void
+
+  constructor(options: ChartBridgeOptions) {
+    this.sessionId = options.sessionId ?? crypto.randomUUID()
+    this.autoReconnect = options.autoReconnect ?? true
+    this.reconnectDelay = options.reconnectDelay ?? 3000
+    this.heartbeatInterval = options.heartbeatInterval ?? 30_000
+    this.onToolCall = options.onToolCall
+    this.wsImpl = options.wsImpl ?? WebSocket
+    this.wsUrl = options.wsUrl
+  }
+
+  private wsUrl: string
+
+  async connect(): Promise<void> {
+    if (this.destroyed) return
+    this.disconnect()
+
+    return new Promise((resolve, reject) => {
+      try {
+        const ws = new this.wsImpl(this.wsUrl)
+
+        ws.onopen = () => {
+          this.ws = ws
+          console.info(
+            `[ChartBridge] WS opened → sending register (sessionId=${this.sessionId})`,
+          )
+          ws.send(JSON.stringify({ type: 'register', sessionId: this.sessionId }))
+          this.startHeartbeat()
+          this.onConnected?.()
+          this.emit('connected')
+          resolve()
+        }
+
+        ws.onmessage = (event: MessageEvent) => {
+          let msg: Record<string, unknown>
+          try {
+            msg = JSON.parse(event.data as string)
+          } catch {
+            return
+          }
+          this.handleMessage(msg)
+        }
+
+        ws.onclose = () => {
+          console.warn(
+            `[ChartBridge] WS closed, autoReconnect=${this.autoReconnect}`,
+          )
+          this.ws = null
+          this.stopHeartbeat()
+          this.onDisconnected?.()
+          this.emit('disconnected')
+          if (this.autoReconnect && !this.destroyed) {
+            this.scheduleReconnect()
+          }
+        }
+
+        ws.onerror = () => {
+          console.error(`[ChartBridge] WS error — connection failed`)
+          const err = new Error('WebSocket connection failed')
+          this.onError?.(err)
+          this.emit('error', err)
+          reject(err)
+        }
+      } catch (err) {
+        reject(err)
+      }
+    })
+  }
+
+  disconnect(): void {
+    this.ws?.close()
+    this.ws = null
+    this.cancelReconnect()
+    this.stopHeartbeat()
+  }
+
+  destroy(): void {
+    this.destroyed = true
+    this.disconnect()
+    this.listeners.clear()
+  }
+
+  private handleMessage(msg: Record<string, unknown>): void {
+    switch (msg.type) {
+      case 'registered':
+        break
+
+      case 'tool:call': {
+        const call = msg.call as ToolCall
+        const requestId = msg.requestId as string
+        this.dispatchToolCall(requestId, call)
+        break
+      }
+
+      case 'ping': {
+        this.ws?.send(JSON.stringify({ type: 'pong' }))
+        break
+      }
+    }
+  }
+
+  private async dispatchToolCall(requestId: string, call: ToolCall): Promise<void> {
+    const result = await this.onToolCall(call)
+    this.sendResult(requestId, result)
+
+    if (this.onStateChange) {
+      this.onStateChange()
+    }
+    this.emit('stateChanged')
+  }
+
+  private sendResult(requestId: string, result: ToolResult): void {
+    this.ws?.send(
+      JSON.stringify({
+        type: 'tool:result',
+        requestId,
+        result,
+      }),
+    )
+  }
+
+  sendStateUpdate(
+    descriptions: Record<string, ControllerDescription>,
+  ): void {
+    this.ws?.send(
+      JSON.stringify({
+        type: 'state:update',
+        sessionId: this.sessionId,
+        descriptions,
+      }),
+    )
+  }
+
+  private startHeartbeat(): void {
+    this.stopHeartbeat()
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === 1) {
+        this.ws.send(JSON.stringify({ type: 'ping' }))
+      }
+    }, this.heartbeatInterval)
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer !== null) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = null
+    }
+  }
+
+  private scheduleReconnect(): void {
+    this.cancelReconnect()
+    this.reconnectTimer = setTimeout(() => {
+      if (!this.destroyed) {
+        this.connect()
+      }
+    }, this.reconnectDelay)
+  }
+
+  private cancelReconnect(): void {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+  }
+
+  private emit(event: ChartBridgeEvent, ...args: unknown[]): void {
+    this.listeners.get(event)?.forEach((fn) => fn(...args))
+  }
+
+  on(event: ChartBridgeEvent, handler: MessageHandler): () => void {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set())
+    }
+    this.listeners.get(event)!.add(handler)
+    return () => this.listeners.get(event)?.delete(handler)
+  }
+
+  off(event: ChartBridgeEvent, handler: MessageHandler): void {
+    this.listeners.get(event)?.delete(handler)
+  }
+}

package/src/mcp/index.ts

@@ -0,0 +1,2 @@
+export { ChartBridge, type ChartBridgeOptions, type ChartBridgeEvent } from './chartBridge'
+export type { ToolCall, ToolResult, ControllerDescription, ToolCallHandler } from './types'

package/src/mcp/types.ts

@@ -0,0 +1,19 @@
+export interface ToolCall {
+  name: string
+  input: Record<string, unknown>
+}
+
+export interface ToolResult {
+  success: boolean
+  error?: string
+  data?: unknown
+}
+
+export type ToolCallHandler = (call: ToolCall) => ToolResult | Promise<ToolResult>
+
+export interface ControllerDescription {
+  controllerId: string
+  summary: string
+  facts: Readonly<Record<string, string | number | boolean | null>>
+  warnings?: ReadonlyArray<string>
+}

package/src/plugin/types.ts

@@ -273,6 +273,8 @@ export interface RenderContext {
   ctx: CanvasRenderingContext2D
   pane: PaneInfo
   data: unknown[]
+  /** K线级别，如 'daily'、'5min'、'15min' */
+  period: string
   comparisonData?: ReadonlyMap<string, ReadonlyArray<KLineData>>
   comparisonSymbols?: ReadonlyArray<import('../controllers/types').SymbolSpec>
   comparisonColors?: ReadonlyMap<string, string>

package/src/semantic/index.ts

@@ -1,5 +1,6 @@
 export type {
   SemanticChartConfig,
+  AdjustType,
   DataConfig,
   IndicatorsConfig,
   MainIndicatorConfig,