tickflow-assist 0.2.0

package/dist/storage/repositories/key-levels-history-repo.js

@@ -0,0 +1,91 @@
+import { keyLevelsHistorySchema } from "../schemas.js";
+const KEY_LEVELS_HISTORY_TABLE = "key_levels_history";
+export class KeyLevelsHistoryRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async saveDailySnapshot(entry) {
+        const row = toKeyLevelsHistoryRow(entry);
+        if (!(await this.db.hasTable(KEY_LEVELS_HISTORY_TABLE))) {
+            await this.db.createTable(KEY_LEVELS_HISTORY_TABLE, [row], keyLevelsHistorySchema);
+            return;
+        }
+        const table = await this.db.openTable(KEY_LEVELS_HISTORY_TABLE);
+        await table.delete(`symbol = '${escapeSqlString(entry.symbol)}' and analysis_date = '${escapeSqlString(entry.analysis_date)}'`);
+        await table.add([row]);
+    }
+    async listBySymbol(symbol, limit) {
+        if (!(await this.db.hasTable(KEY_LEVELS_HISTORY_TABLE))) {
+            return [];
+        }
+        const table = await this.db.openTable(KEY_LEVELS_HISTORY_TABLE);
+        const rows = (await table
+            .query()
+            .where(`symbol = '${escapeSqlString(symbol)}'`)
+            .toArray());
+        return limitRows(rows, limit).map(fromKeyLevelsHistoryRow);
+    }
+    async listLatest(limit) {
+        if (!(await this.db.hasTable(KEY_LEVELS_HISTORY_TABLE))) {
+            return [];
+        }
+        const table = await this.db.openTable(KEY_LEVELS_HISTORY_TABLE);
+        const rows = (await table.query().toArray());
+        return limitRows(rows, limit).map(fromKeyLevelsHistoryRow);
+    }
+}
+function limitRows(rows, limit) {
+    const normalized = limit == null ? rows.length : Math.max(1, Math.trunc(limit));
+    return rows.slice(-normalized).reverse();
+}
+function toKeyLevelsHistoryRow(entry) {
+    return {
+        symbol: entry.symbol,
+        analysis_date: entry.analysis_date,
+        activated_at: entry.activated_at,
+        profile: entry.profile,
+        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,
+        analysis_text: entry.analysis_text,
+        score: entry.score == null ? null : Math.trunc(entry.score),
+    };
+}
+function fromKeyLevelsHistoryRow(row) {
+    return {
+        symbol: String(row.symbol),
+        analysis_date: String(row.analysis_date),
+        activated_at: String(row.activated_at ?? ""),
+        profile: "composite",
+        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),
+        analysis_text: String(row.analysis_text ?? ""),
+        score: toNullableNumber(row.score),
+    };
+}
+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/key-levels-repo.d.ts

@@ -0,0 +1,9 @@
+import { Database } from "../db.js";
+import type { KeyLevels } from "../../types/domain.js";
+export declare class KeyLevelsRepository {
+    private readonly db;
+    constructor(db: Database);
+    save(symbol: string, levels: KeyLevels): Promise<void>;
+    remove(symbol: string): Promise<void>;
+    getBySymbol(symbol: string): Promise<KeyLevels | null>;
+}

package/dist/storage/repositories/key-levels-repo.js

@@ -0,0 +1,83 @@
+import { keyLevelsSchema } from "../schemas.js";
+const KEY_LEVELS_TABLE = "key_levels";
+export class KeyLevelsRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async save(symbol, levels) {
+        const row = toKeyLevelsRow(symbol, levels);
+        if (!(await this.db.hasTable(KEY_LEVELS_TABLE))) {
+            await this.db.createTable(KEY_LEVELS_TABLE, [row], keyLevelsSchema);
+            return;
+        }
+        const table = await this.db.openTable(KEY_LEVELS_TABLE);
+        await table.delete(`symbol = '${escapeSqlString(symbol)}'`);
+        await table.add([row]);
+    }
+    async remove(symbol) {
+        if (!(await this.db.hasTable(KEY_LEVELS_TABLE))) {
+            return;
+        }
+        const table = await this.db.openTable(KEY_LEVELS_TABLE);
+        await table.delete(`symbol = '${escapeSqlString(symbol)}'`);
+    }
+    async getBySymbol(symbol) {
+        if (!(await this.db.hasTable(KEY_LEVELS_TABLE))) {
+            return null;
+        }
+        const table = await this.db.openTable(KEY_LEVELS_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),
+            current_price: Number(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),
+            analysis_text: String(row.analysis_text ?? ""),
+            score: Number(row.score ?? 0),
+        };
+    }
+}
+function toKeyLevelsRow(symbol, levels) {
+    return {
+        symbol,
+        analysis_date: levels.analysis_date ?? "",
+        current_price: levels.current_price,
+        stop_loss: levels.stop_loss ?? null,
+        breakthrough: levels.breakthrough ?? null,
+        support: levels.support ?? null,
+        cost_level: levels.cost_level ?? null,
+        resistance: levels.resistance ?? null,
+        take_profit: levels.take_profit ?? null,
+        gap: levels.gap ?? null,
+        target: levels.target ?? null,
+        round_number: levels.round_number ?? null,
+        analysis_text: levels.analysis_text,
+        score: levels.score,
+    };
+}
+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/klines-repo.d.ts

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

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

@@ -0,0 +1,60 @@
+import { klinesDailySchema } from "../schemas.js";
+const KLINES_TABLE = "klines_daily";
+export class KlinesRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async saveAll(symbol, rows) {
+        if (!(await this.db.hasTable(KLINES_TABLE))) {
+            await this.db.createTable(KLINES_TABLE, rows.map(toKlineRow), klinesDailySchema);
+            return;
+        }
+        const table = await this.db.openTable(KLINES_TABLE);
+        await table.delete(`symbol = '${escapeSqlString(symbol)}'`);
+        if (rows.length > 0) {
+            await table.add(rows.map(toKlineRow));
+        }
+    }
+    async listBySymbol(symbol) {
+        if (!(await this.db.hasTable(KLINES_TABLE))) {
+            return [];
+        }
+        const table = await this.db.openTable(KLINES_TABLE);
+        const query = table
+            .query()
+            .where(`symbol = '${escapeSqlString(symbol)}'`);
+        const rows = (await query.toArray());
+        return rows
+            .map((row) => ({
+            symbol: String(row.symbol),
+            trade_date: String(row.trade_date),
+            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),
+        }))
+            .sort((a, b) => a.trade_date.localeCompare(b.trade_date));
+    }
+}
+function toKlineRow(row) {
+    return {
+        symbol: row.symbol,
+        trade_date: row.trade_date,
+        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,
+    };
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}

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

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

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

@@ -0,0 +1,107 @@
+import { newsAnalysisSchema } from "../schemas.js";
+const NEWS_ANALYSIS_TABLE = "news_analysis";
+export class NewsAnalysisRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async append(entry) {
+        const row = toNewsAnalysisRow(entry);
+        if (!(await this.db.hasTable(NEWS_ANALYSIS_TABLE))) {
+            await this.db.createTable(NEWS_ANALYSIS_TABLE, [row], newsAnalysisSchema);
+            return;
+        }
+        const table = await this.db.openTable(NEWS_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(NEWS_ANALYSIS_TABLE))) {
+            return [];
+        }
+        const table = await this.db.openTable(NEWS_ANALYSIS_TABLE);
+        const rows = (await table
+            .query()
+            .where(`symbol = '${escapeSqlString(symbol)}'`)
+            .toArray());
+        return rows.slice(-Math.max(1, limit)).reverse().map((row) => fromNewsAnalysisRow(row));
+    }
+}
+function toNewsAnalysisRow(entry) {
+    return {
+        symbol: entry.symbol,
+        analysis_date: entry.analysis_date,
+        query: entry.query,
+        analysis_text: entry.analysis_text,
+        score: entry.score == null ? null : Math.trunc(entry.score),
+        bias: entry.bias,
+        catalysts_json: JSON.stringify(entry.catalysts),
+        risks_json: JSON.stringify(entry.risks),
+        watch_items_json: JSON.stringify(entry.watch_items),
+        source_count: entry.source_count,
+        evidence_json: JSON.stringify(entry.evidence),
+    };
+}
+function fromNewsAnalysisRow(row) {
+    return {
+        symbol: String(row.symbol),
+        analysis_date: String(row.analysis_date),
+        query: String(row.query ?? ""),
+        analysis_text: String(row.analysis_text ?? ""),
+        score: toNullableNumber(row.score),
+        bias: normalizeBias(row.bias),
+        catalysts: parseJsonArray(row.catalysts_json),
+        risks: parseJsonArray(row.risks_json),
+        watch_items: parseJsonArray(row.watch_items_json),
+        source_count: Number(row.source_count ?? 0),
+        evidence: parseJsonObject(row.evidence_json, {
+            available: false,
+            source_count: 0,
+            documents: [],
+        }),
+    };
+}
+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/technical-analysis-repo.d.ts

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

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

@@ -0,0 +1,80 @@
+import { technicalAnalysisSchema } from "../schemas.js";
+const TECHNICAL_ANALYSIS_TABLE = "technical_analysis";
+export class TechnicalAnalysisRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async append(entry) {
+        const row = toTechnicalAnalysisRow(entry);
+        if (!(await this.db.hasTable(TECHNICAL_ANALYSIS_TABLE))) {
+            await this.db.createTable(TECHNICAL_ANALYSIS_TABLE, [row], technicalAnalysisSchema);
+            return;
+        }
+        const table = await this.db.openTable(TECHNICAL_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(TECHNICAL_ANALYSIS_TABLE))) {
+            return [];
+        }
+        const table = await this.db.openTable(TECHNICAL_ANALYSIS_TABLE);
+        const rows = (await table
+            .query()
+            .where(`symbol = '${escapeSqlString(symbol)}'`)
+            .toArray());
+        return rows.slice(-Math.max(1, limit)).reverse().map((row) => fromTechnicalAnalysisRow(row));
+    }
+}
+function toTechnicalAnalysisRow(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),
+    };
+}
+function fromTechnicalAnalysisRow(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),
+    };
+}
+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/watchlist-repo.d.ts

@@ -0,0 +1,10 @@
+import type { WatchlistItem } from "../../types/domain.js";
+import { Database } from "../db.js";
+export declare class WatchlistRepository {
+    private readonly db;
+    constructor(db: Database);
+    list(): Promise<WatchlistItem[]>;
+    upsert(item: WatchlistItem): Promise<void>;
+    remove(symbol: string): Promise<boolean>;
+    private ensureSchema;
+}

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

@@ -0,0 +1,124 @@
+import { watchlistSchema } from "../schemas.js";
+import { normalizeCostPrice } from "../../utils/cost-price.js";
+const WATCHLIST_TABLE = "watchlist";
+export class WatchlistRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async list() {
+        await this.ensureSchema();
+        const items = await this.db.tableToArray(WATCHLIST_TABLE);
+        return items
+            .map((item) => ({
+            symbol: String(item.symbol),
+            name: String(item.name ?? ""),
+            costPrice: normalizeCostPrice(item.costPrice),
+            addedAt: String(item.addedAt ?? ""),
+            sector: normalizeNullableString(item.sector),
+            themes: parseThemes(item.themes),
+            themeQuery: normalizeNullableString(item.themeQuery),
+            themeUpdatedAt: normalizeNullableString(item.themeUpdatedAt),
+        }))
+            .sort((a, b) => a.symbol.localeCompare(b.symbol));
+    }
+    async upsert(item) {
+        const row = toWatchlistRow(item);
+        if (!(await this.db.hasTable(WATCHLIST_TABLE))) {
+            await this.db.createTable(WATCHLIST_TABLE, [row], watchlistSchema);
+            return;
+        }
+        await this.ensureSchema();
+        const table = await this.db.openTable(WATCHLIST_TABLE);
+        await table.delete(`symbol = '${escapeSqlString(item.symbol)}'`);
+        await table.add([row]);
+    }
+    async remove(symbol) {
+        if (!(await this.db.hasTable(WATCHLIST_TABLE))) {
+            return false;
+        }
+        const table = await this.db.openTable(WATCHLIST_TABLE);
+        const countBefore = await table.countRows(`symbol = '${escapeSqlString(symbol)}'`);
+        if (countBefore === 0) {
+            return false;
+        }
+        await table.delete(`symbol = '${escapeSqlString(symbol)}'`);
+        return true;
+    }
+    async ensureSchema() {
+        if (!(await this.db.hasTable(WATCHLIST_TABLE))) {
+            return;
+        }
+        const fields = await this.db.describeTable(WATCHLIST_TABLE);
+        const fieldNames = new Set(fields.map((field) => field.name));
+        const missingColumns = [];
+        if (!fieldNames.has("sector")) {
+            missingColumns.push({ name: "sector", valueSql: "''" });
+        }
+        if (!fieldNames.has("themes")) {
+            missingColumns.push({ name: "themes", valueSql: "'[]'" });
+        }
+        if (!fieldNames.has("themeQuery")) {
+            missingColumns.push({ name: "themeQuery", valueSql: "''" });
+        }
+        if (!fieldNames.has("themeUpdatedAt")) {
+            missingColumns.push({ name: "themeUpdatedAt", valueSql: "''" });
+        }
+        if (missingColumns.length === 0) {
+            return;
+        }
+        const table = await this.db.openTable(WATCHLIST_TABLE);
+        await table.addColumns(missingColumns);
+    }
+}
+function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}
+function toWatchlistRow(item) {
+    return {
+        symbol: item.symbol,
+        name: item.name,
+        costPrice: item.costPrice ?? 0,
+        addedAt: item.addedAt,
+        sector: item.sector ?? "",
+        themes: JSON.stringify(item.themes),
+        themeQuery: item.themeQuery ?? "",
+        themeUpdatedAt: item.themeUpdatedAt ?? "",
+    };
+}
+function normalizeNullableString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const text = value.trim();
+    return text || null;
+}
+function parseThemes(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => String(item ?? "").trim())
+            .filter(Boolean);
+    }
+    if (typeof value !== "string") {
+        return [];
+    }
+    const text = value.trim();
+    if (!text) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(text);
+        if (Array.isArray(parsed)) {
+            return parsed
+                .map((item) => String(item ?? "").trim())
+                .filter(Boolean);
+        }
+    }
+    catch {
+        // Fall back to delimiter parsing for legacy rows.
+    }
+    return text
+        .split(/[、,，;；|]/)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}

package/dist/storage/schemas.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from "apache-arrow";
+export declare const watchlistSchema: Schema<any>;
+export declare const klinesDailySchema: Schema<any>;
+export declare const klinesIntradaySchema: Schema<any>;
+export declare const indicatorsSchema: Schema<any>;
+export declare const keyLevelsSchema: Schema<any>;
+export declare const keyLevelsHistorySchema: Schema<any>;
+export declare const analysisLogSchema: Schema<any>;
+export declare const technicalAnalysisSchema: Schema<any>;
+export declare const financialAnalysisSchema: Schema<any>;
+export declare const newsAnalysisSchema: Schema<any>;
+export declare const compositeAnalysisSchema: Schema<any>;
+export declare const alertLogSchema: Schema<any>;