tickflow-assist 0.2.0

package/dist/storage/db.js

@@ -0,0 +1,70 @@
+import { mkdir } from "node:fs/promises";
+export class Database {
+    baseDir;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    async getConnection() {
+        return this.connect();
+    }
+    async hasTable(name) {
+        const connection = await this.getConnection();
+        const tableNames = await this.listTableNames(connection);
+        return tableNames.includes(name);
+    }
+    async listTables() {
+        const connection = await this.getConnection();
+        return this.listTableNames(connection);
+    }
+    async openTable(name) {
+        const connection = await this.getConnection();
+        return connection.openTable(name);
+    }
+    async createTable(name, rows, schema) {
+        const connection = await this.getConnection();
+        return connection.createTable(name, rows, schema ? { schema } : undefined);
+    }
+    async tableToArray(name) {
+        if (!(await this.hasTable(name))) {
+            return [];
+        }
+        const table = await this.openTable(name);
+        const query = table.query?.();
+        if (!query?.toArray) {
+            throw new Error(`LanceDB query().toArray() is unavailable for table ${name}`);
+        }
+        return query.toArray();
+    }
+    async describeTable(name) {
+        if (!(await this.hasTable(name))) {
+            return [];
+        }
+        const table = await this.openTable(name);
+        const schema = await table.schema();
+        const fields = schema.fields ?? [];
+        return fields.map((field) => ({
+            name: field.name,
+            type: String(field.type ?? "unknown"),
+            nullable: Boolean(field.nullable),
+        }));
+    }
+    async connect() {
+        await mkdir(this.baseDir, { recursive: true });
+        const lancedb = (await import("@lancedb/lancedb"));
+        return lancedb.connect(this.baseDir);
+    }
+    async listTableNames(connection) {
+        const conn = connection;
+        if (conn.tableNames) {
+            return conn.tableNames();
+        }
+        if (conn.listTables) {
+            const result = await conn.listTables();
+            if (Array.isArray(result)) {
+                return result;
+            }
+            return result.tables ?? [];
+        }
+        throw new Error("Unable to list LanceDB tables");
+    }
+}

package/dist/storage/repositories/alert-log-repo.d.ts

@@ -0,0 +1,15 @@
+import { Database } from "../db.js";
+export interface AlertLogEntry {
+    symbol: string;
+    alert_date: string;
+    rule_name: string;
+    message: string;
+    triggered_at: string;
+}
+export declare class AlertLogRepository {
+    private readonly db;
+    constructor(db: Database);
+    append(entry: AlertLogEntry): Promise<void>;
+    listByNaturalDate(date: string): Promise<AlertLogEntry[]>;
+    isSentThisSession(symbol: string, ruleName: string, sessionKey: string): Promise<boolean>;
+}

package/dist/storage/repositories/alert-log-repo.js

@@ -0,0 +1,54 @@
+import { alertLogSchema } from "../schemas.js";
+const ALERT_LOG_TABLE = "alert_log";
+export class AlertLogRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async append(entry) {
+        const row = {
+            symbol: entry.symbol,
+            alert_date: entry.alert_date,
+            rule_name: entry.rule_name,
+            message: entry.message,
+            triggered_at: entry.triggered_at,
+        };
+        if (!(await this.db.hasTable(ALERT_LOG_TABLE))) {
+            await this.db.createTable(ALERT_LOG_TABLE, [row], alertLogSchema);
+            return;
+        }
+        const table = await this.db.openTable(ALERT_LOG_TABLE);
+        await table.add([row]);
+    }
+    async listByNaturalDate(date) {
+        if (!(await this.db.hasTable(ALERT_LOG_TABLE))) {
+            return [];
+        }
+        const table = await this.db.openTable(ALERT_LOG_TABLE);
+        const rows = (await table
+            .query()
+            .where(`alert_date IN ('${date}_AM', '${date}_PM')`)
+            .toArray());
+        return rows.map((row) => ({
+            symbol: String(row.symbol),
+            alert_date: String(row.alert_date),
+            rule_name: String(row.rule_name),
+            message: String(row.message ?? ""),
+            triggered_at: String(row.triggered_at ?? ""),
+        }));
+    }
+    async isSentThisSession(symbol, ruleName, sessionKey) {
+        if (!(await this.db.hasTable(ALERT_LOG_TABLE))) {
+            return false;
+        }
+        const table = await this.db.openTable(ALERT_LOG_TABLE);
+        const rows = (await table
+            .query()
+            .where(`symbol = '${escapeSqlString(symbol)}' AND rule_name = '${escapeSqlString(ruleName)}' AND alert_date = '${escapeSqlString(sessionKey)}'`)
+            .toArray());
+        return rows.length > 0;
+    }
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

package/dist/storage/repositories/analysis-log-repo.d.ts

@@ -0,0 +1,8 @@
+import { Database } from "../db.js";
+import type { AnalysisLogEntry } from "../../types/domain.js";
+export declare class AnalysisLogRepository {
+    private readonly db;
+    constructor(db: Database);
+    append(entry: AnalysisLogEntry): Promise<void>;
+    getLatest(symbol: string): Promise<AnalysisLogEntry | null>;
+}

package/dist/storage/repositories/analysis-log-repo.js

@@ -0,0 +1,48 @@
+import { analysisLogSchema } from "../schemas.js";
+const ANALYSIS_LOG_TABLE = "analysis_log";
+export class AnalysisLogRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async append(entry) {
+        const row = toAnalysisLogRow(entry);
+        if (!(await this.db.hasTable(ANALYSIS_LOG_TABLE))) {
+            await this.db.createTable(ANALYSIS_LOG_TABLE, [row], analysisLogSchema);
+            return;
+        }
+        const table = await this.db.openTable(ANALYSIS_LOG_TABLE);
+        await table.add([row]);
+    }
+    async getLatest(symbol) {
+        if (!(await this.db.hasTable(ANALYSIS_LOG_TABLE))) {
+            return null;
+        }
+        const table = await this.db.openTable(ANALYSIS_LOG_TABLE);
+        const rows = (await table
+            .query()
+            .where(`symbol = '${escapeSqlString(symbol)}'`)
+            .toArray());
+        if (rows.length === 0) {
+            return null;
+        }
+        const row = rows[rows.length - 1];
+        return {
+            symbol: String(row.symbol),
+            analysis_date: String(row.analysis_date),
+            analysis_text: String(row.analysis_text),
+            structured_ok: Boolean(Number(row.structured_ok ?? 0)),
+        };
+    }
+}
+function toAnalysisLogRow(entry) {
+    return {
+        symbol: entry.symbol,
+        analysis_date: entry.analysis_date,
+        analysis_text: entry.analysis_text,
+        structured_ok: entry.structured_ok ? 1 : 0,
+    };
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

package/dist/storage/repositories/composite-analysis-repo.d.ts

@@ -0,0 +1,9 @@
+import type { CompositeAnalysisEntry } from "../../types/domain.js";
+import { Database } from "../db.js";
+export declare class CompositeAnalysisRepository {
+    private readonly db;
+    constructor(db: Database);
+    append(entry: CompositeAnalysisEntry): Promise<void>;
+    getLatest(symbol: string): Promise<CompositeAnalysisEntry | null>;
+    listLatest(symbol: string, limit: number): Promise<CompositeAnalysisEntry[]>;
+}

package/dist/storage/repositories/composite-analysis-repo.js

@@ -0,0 +1,116 @@
+import { compositeAnalysisSchema } from "../schemas.js";
+const COMPOSITE_ANALYSIS_TABLE = "composite_analysis";
+export class CompositeAnalysisRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async append(entry) {
+        const row = toCompositeAnalysisRow(entry);
+        if (!(await this.db.hasTable(COMPOSITE_ANALYSIS_TABLE))) {
+            await this.db.createTable(COMPOSITE_ANALYSIS_TABLE, [row], compositeAnalysisSchema);
+            return;
+        }
+        const table = await this.db.openTable(COMPOSITE_ANALYSIS_TABLE);
+        await table.add([row]);
+    }
+    async getLatest(symbol) {
+        const rows = await this.listLatest(symbol, 1);
+        return rows[0] ?? null;
+    }
+    async listLatest(symbol, limit) {
+        if (!(await this.db.hasTable(COMPOSITE_ANALYSIS_TABLE))) {
+            return [];
+        }
+        const table = await this.db.openTable(COMPOSITE_ANALYSIS_TABLE);
+        const rows = (await table
+            .query()
+            .where(`symbol = '${escapeSqlString(symbol)}'`)
+            .toArray());
+        return rows.slice(-Math.max(1, limit)).reverse().map((row) => fromCompositeAnalysisRow(row));
+    }
+}
+function toCompositeAnalysisRow(entry) {
+    return {
+        symbol: entry.symbol,
+        analysis_date: entry.analysis_date,
+        analysis_text: entry.analysis_text,
+        structured_ok: entry.structured_ok ? 1 : 0,
+        current_price: entry.current_price,
+        stop_loss: entry.stop_loss,
+        breakthrough: entry.breakthrough,
+        support: entry.support,
+        cost_level: entry.cost_level,
+        resistance: entry.resistance,
+        take_profit: entry.take_profit,
+        gap: entry.gap,
+        target: entry.target,
+        round_number: entry.round_number,
+        score: entry.score == null ? null : Math.trunc(entry.score),
+        technical_score: entry.technical_score == null ? null : Math.trunc(entry.technical_score),
+        financial_score: entry.financial_score == null ? null : Math.trunc(entry.financial_score),
+        news_score: entry.news_score == null ? null : Math.trunc(entry.news_score),
+        financial_bias: entry.financial_bias,
+        news_bias: entry.news_bias,
+        evidence_json: JSON.stringify(entry.evidence),
+    };
+}
+function fromCompositeAnalysisRow(row) {
+    return {
+        symbol: String(row.symbol),
+        analysis_date: String(row.analysis_date),
+        analysis_text: String(row.analysis_text ?? ""),
+        structured_ok: Boolean(Number(row.structured_ok ?? 0)),
+        current_price: toNullableNumber(row.current_price),
+        stop_loss: toNullableNumber(row.stop_loss),
+        breakthrough: toNullableNumber(row.breakthrough),
+        support: toNullableNumber(row.support),
+        cost_level: toNullableNumber(row.cost_level),
+        resistance: toNullableNumber(row.resistance),
+        take_profit: toNullableNumber(row.take_profit),
+        gap: toNullableNumber(row.gap),
+        target: toNullableNumber(row.target),
+        round_number: toNullableNumber(row.round_number),
+        score: toNullableNumber(row.score),
+        technical_score: toNullableNumber(row.technical_score),
+        financial_score: toNullableNumber(row.financial_score),
+        news_score: toNullableNumber(row.news_score),
+        financial_bias: normalizeBias(row.financial_bias),
+        news_bias: normalizeBias(row.news_bias),
+        evidence: parseJsonObject(row.evidence_json, {
+            technical_structured: false,
+            financial_available: false,
+            financial_latest_period_end: null,
+            news_available: false,
+            news_query: "",
+            news_source_count: 0,
+        }),
+    };
+}
+function toNullableNumber(value) {
+    if (value == null) {
+        return null;
+    }
+    const num = Number(value);
+    return Number.isFinite(num) ? num : null;
+}
+function parseJsonObject(value, fallback) {
+    if (typeof value !== "string" || !value.trim()) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+function normalizeBias(value) {
+    if (value === "positive" || value === "negative") {
+        return value;
+    }
+    return "neutral";
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

package/dist/storage/repositories/financial-analysis-repo.d.ts

@@ -0,0 +1,9 @@
+import type { FinancialAnalysisEntry } from "../../types/domain.js";
+import { Database } from "../db.js";
+export declare class FinancialAnalysisRepository {
+    private readonly db;
+    constructor(db: Database);
+    append(entry: FinancialAnalysisEntry): Promise<void>;
+    getLatest(symbol: string): Promise<FinancialAnalysisEntry | null>;
+    listLatest(symbol: string, limit: number): Promise<FinancialAnalysisEntry[]>;
+}

package/dist/storage/repositories/financial-analysis-repo.js

@@ -0,0 +1,107 @@
+import { financialAnalysisSchema } from "../schemas.js";
+const FINANCIAL_ANALYSIS_TABLE = "financial_analysis";
+export class FinancialAnalysisRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async append(entry) {
+        const row = toFinancialAnalysisRow(entry);
+        if (!(await this.db.hasTable(FINANCIAL_ANALYSIS_TABLE))) {
+            await this.db.createTable(FINANCIAL_ANALYSIS_TABLE, [row], financialAnalysisSchema);
+            return;
+        }
+        const table = await this.db.openTable(FINANCIAL_ANALYSIS_TABLE);
+        await table.add([row]);
+    }
+    async getLatest(symbol) {
+        const rows = await this.listLatest(symbol, 1);
+        return rows[0] ?? null;
+    }
+    async listLatest(symbol, limit) {
+        if (!(await this.db.hasTable(FINANCIAL_ANALYSIS_TABLE))) {
+            return [];
+        }
+        const table = await this.db.openTable(FINANCIAL_ANALYSIS_TABLE);
+        const rows = (await table
+            .query()
+            .where(`symbol = '${escapeSqlString(symbol)}'`)
+            .toArray());
+        return rows.slice(-Math.max(1, limit)).reverse().map((row) => fromFinancialAnalysisRow(row));
+    }
+}
+function toFinancialAnalysisRow(entry) {
+    return {
+        symbol: entry.symbol,
+        analysis_date: entry.analysis_date,
+        analysis_text: entry.analysis_text,
+        score: entry.score == null ? null : Math.trunc(entry.score),
+        bias: entry.bias,
+        strengths_json: JSON.stringify(entry.strengths),
+        risks_json: JSON.stringify(entry.risks),
+        watch_items_json: JSON.stringify(entry.watch_items),
+        evidence_json: JSON.stringify(entry.evidence),
+    };
+}
+function fromFinancialAnalysisRow(row) {
+    return {
+        symbol: String(row.symbol),
+        analysis_date: String(row.analysis_date),
+        analysis_text: String(row.analysis_text ?? ""),
+        score: toNullableNumber(row.score),
+        bias: normalizeBias(row.bias),
+        strengths: parseJsonArray(row.strengths_json),
+        risks: parseJsonArray(row.risks_json),
+        watch_items: parseJsonArray(row.watch_items_json),
+        evidence: parseJsonObject(row.evidence_json, {
+            available: false,
+            latest_period_end: null,
+            latest_announce_date: null,
+            income_count: 0,
+            metrics_count: 0,
+            cash_flow_count: 0,
+            balance_sheet_count: 0,
+        }),
+    };
+}
+function toNullableNumber(value) {
+    if (value == null) {
+        return null;
+    }
+    const num = Number(value);
+    return Number.isFinite(num) ? num : null;
+}
+function parseJsonArray(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed)
+            ? parsed.map((item) => String(item ?? "").trim()).filter(Boolean)
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseJsonObject(value, fallback) {
+    if (typeof value !== "string" || !value.trim()) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+function normalizeBias(value) {
+    if (value === "positive" || value === "negative") {
+        return value;
+    }
+    return "neutral";
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

package/dist/storage/repositories/indicators-repo.d.ts

@@ -0,0 +1,8 @@
+import { Database } from "../db.js";
+import type { IndicatorRow } from "../../types/indicator.js";
+export declare class IndicatorsRepository {
+    private readonly db;
+    constructor(db: Database);
+    saveAll(symbol: string, rows: IndicatorRow[]): Promise<void>;
+    listBySymbol(symbol: string): Promise<IndicatorRow[]>;
+}

package/dist/storage/repositories/indicators-repo.js

@@ -0,0 +1,98 @@
+import { indicatorsSchema } from "../schemas.js";
+const INDICATORS_TABLE = "indicators";
+export class IndicatorsRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async saveAll(symbol, rows) {
+        const dbRows = rows.map((row) => toIndicatorRow(symbol, row));
+        if (!(await this.db.hasTable(INDICATORS_TABLE))) {
+            await this.db.createTable(INDICATORS_TABLE, dbRows, indicatorsSchema);
+            return;
+        }
+        const table = await this.db.openTable(INDICATORS_TABLE);
+        await table.delete(`symbol = '${escapeSqlString(symbol)}'`);
+        if (dbRows.length > 0) {
+            await table.add(dbRows);
+        }
+    }
+    async listBySymbol(symbol) {
+        if (!(await this.db.hasTable(INDICATORS_TABLE))) {
+            return [];
+        }
+        const table = await this.db.openTable(INDICATORS_TABLE);
+        const rows = (await table
+            .query()
+            .where(`symbol = '${escapeSqlString(symbol)}'`)
+            .toArray());
+        return rows
+            .map((row) => ({
+            symbol: String(row.symbol),
+            trade_date: String(row.trade_date),
+            ma5: toNullableNumber(row.ma5),
+            ma10: toNullableNumber(row.ma10),
+            ma20: toNullableNumber(row.ma20),
+            ma60: toNullableNumber(row.ma60),
+            macd: toNullableNumber(row.macd),
+            macd_signal: toNullableNumber(row.macd_signal),
+            macd_hist: toNullableNumber(row.macd_hist),
+            kdj_k: toNullableNumber(row.kdj_k),
+            kdj_d: toNullableNumber(row.kdj_d),
+            kdj_j: toNullableNumber(row.kdj_j),
+            rsi_6: toNullableNumber(row.rsi_6),
+            rsi_12: toNullableNumber(row.rsi_12),
+            rsi_24: toNullableNumber(row.rsi_24),
+            cci: toNullableNumber(row.cci),
+            bias_6: toNullableNumber(row.bias_6),
+            bias_12: toNullableNumber(row.bias_12),
+            bias_24: toNullableNumber(row.bias_24),
+            plus_di: toNullableNumber(row.plus_di),
+            minus_di: toNullableNumber(row.minus_di),
+            adx: toNullableNumber(row.adx),
+            boll_upper: toNullableNumber(row.boll_upper),
+            boll_mid: toNullableNumber(row.boll_mid),
+            boll_lower: toNullableNumber(row.boll_lower),
+        }))
+            .sort((a, b) => a.trade_date.localeCompare(b.trade_date));
+    }
+}
+function toIndicatorRow(symbol, row) {
+    return {
+        symbol,
+        trade_date: row.trade_date,
+        ma5: row.ma5 ?? null,
+        ma10: row.ma10 ?? null,
+        ma20: row.ma20 ?? null,
+        ma60: row.ma60 ?? null,
+        macd: row.macd ?? null,
+        macd_signal: row.macd_signal ?? null,
+        macd_hist: row.macd_hist ?? null,
+        kdj_k: row.kdj_k ?? null,
+        kdj_d: row.kdj_d ?? null,
+        kdj_j: row.kdj_j ?? null,
+        rsi_6: row.rsi_6 ?? null,
+        rsi_12: row.rsi_12 ?? null,
+        rsi_24: row.rsi_24 ?? null,
+        cci: row.cci ?? null,
+        bias_6: row.bias_6 ?? null,
+        bias_12: row.bias_12 ?? null,
+        bias_24: row.bias_24 ?? null,
+        plus_di: row.plus_di ?? null,
+        minus_di: row.minus_di ?? null,
+        adx: row.adx ?? null,
+        boll_upper: row.boll_upper ?? null,
+        boll_mid: row.boll_mid ?? null,
+        boll_lower: row.boll_lower ?? null,
+    };
+}
+function toNullableNumber(value) {
+    if (value == null) {
+        return null;
+    }
+    const num = Number(value);
+    return Number.isFinite(num) ? num : null;
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

package/dist/storage/repositories/intraday-klines-repo.d.ts

@@ -0,0 +1,9 @@
+import type { TickFlowIntradayKlineRow } from "../../types/tickflow.js";
+import { Database } from "../db.js";
+export declare class IntradayKlinesRepository {
+    private readonly db;
+    constructor(db: Database);
+    saveAll(symbol: string, period: string, rows: TickFlowIntradayKlineRow[]): Promise<void>;
+    pruneToTradeDates(symbol: string, period: string, keepTradeDates: string[]): Promise<void>;
+    listBySymbol(symbol: string, period?: string): Promise<TickFlowIntradayKlineRow[]>;
+}

package/dist/storage/repositories/intraday-klines-repo.js

@@ -0,0 +1,102 @@
+import { klinesIntradaySchema } from "../schemas.js";
+const KLINES_INTRADAY_TABLE = "klines_intraday";
+export class IntradayKlinesRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async saveAll(symbol, period, rows) {
+        if (rows.length === 0) {
+            return;
+        }
+        if (!(await this.db.hasTable(KLINES_INTRADAY_TABLE))) {
+            await this.db.createTable(KLINES_INTRADAY_TABLE, rows.map(toIntradayKlineRow), klinesIntradaySchema);
+            return;
+        }
+        const table = await this.db.openTable(KLINES_INTRADAY_TABLE);
+        const tradeDates = uniqueTradeDates(rows);
+        await table.delete(buildDeleteByTradeDatesWhere(symbol, period, tradeDates));
+        await table.add(rows.map(toIntradayKlineRow));
+    }
+    async pruneToTradeDates(symbol, period, keepTradeDates) {
+        if (!(await this.db.hasTable(KLINES_INTRADAY_TABLE))) {
+            return;
+        }
+        const table = await this.db.openTable(KLINES_INTRADAY_TABLE);
+        const base = `symbol = '${escapeSqlString(symbol)}' and period = '${escapeSqlString(period)}'`;
+        if (keepTradeDates.length === 0) {
+            await table.delete(base);
+            return;
+        }
+        await table.delete(`${base} and trade_date not in (${joinSqlStrings(keepTradeDates)})`);
+    }
+    async listBySymbol(symbol, period) {
+        if (!(await this.db.hasTable(KLINES_INTRADAY_TABLE))) {
+            return [];
+        }
+        const filters = [`symbol = '${escapeSqlString(symbol)}'`];
+        if (period) {
+            filters.push(`period = '${escapeSqlString(period)}'`);
+        }
+        const table = await this.db.openTable(KLINES_INTRADAY_TABLE);
+        const rows = (await table
+            .query()
+            .where(filters.join(" and "))
+            .toArray());
+        return rows
+            .map((row) => ({
+            symbol: String(row.symbol),
+            period: String(row.period),
+            trade_date: String(row.trade_date),
+            trade_time: String(row.trade_time),
+            timestamp: Number(row.timestamp),
+            open: Number(row.open),
+            high: Number(row.high),
+            low: Number(row.low),
+            close: Number(row.close),
+            volume: Number(row.volume),
+            amount: Number(row.amount),
+            prev_close: Number(row.prev_close ?? 0),
+            open_interest: toNullableNumber(row.open_interest),
+            settlement_price: toNullableNumber(row.settlement_price),
+        }))
+            .sort((a, b) => a.timestamp - b.timestamp);
+    }
+}
+function uniqueTradeDates(rows) {
+    return [...new Set(rows.map((row) => row.trade_date))];
+}
+function buildDeleteByTradeDatesWhere(symbol, period, tradeDates) {
+    const base = `symbol = '${escapeSqlString(symbol)}' and period = '${escapeSqlString(period)}'`;
+    if (tradeDates.length === 0) {
+        return base;
+    }
+    return `${base} and trade_date in (${joinSqlStrings(tradeDates)})`;
+}
+function joinSqlStrings(values) {
+    return values.map((value) => `'${escapeSqlString(value)}'`).join(", ");
+}
+function toIntradayKlineRow(row) {
+    return {
+        symbol: row.symbol,
+        period: row.period,
+        trade_date: row.trade_date,
+        trade_time: row.trade_time,
+        timestamp: row.timestamp,
+        open: row.open,
+        high: row.high,
+        low: row.low,
+        close: row.close,
+        volume: row.volume,
+        amount: row.amount,
+        prev_close: row.prev_close,
+        open_interest: row.open_interest,
+        settlement_price: row.settlement_price,
+    };
+}
+function toNullableNumber(value) {
+    return value == null ? null : Number(value);
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

package/dist/storage/repositories/key-levels-history-repo.d.ts

@@ -0,0 +1,9 @@
+import type { KeyLevelsHistoryEntry } from "../../types/domain.js";
+import { Database } from "../db.js";
+export declare class KeyLevelsHistoryRepository {
+    private readonly db;
+    constructor(db: Database);
+    saveDailySnapshot(entry: KeyLevelsHistoryEntry): Promise<void>;
+    listBySymbol(symbol: string, limit?: number): Promise<KeyLevelsHistoryEntry[]>;
+    listLatest(limit?: number): Promise<KeyLevelsHistoryEntry[]>;
+}