tickflow-assist 0.3.5 → 0.3.7

package/dist/services/tickflow-client.js

@@ -39,6 +39,38 @@ export class TickFlowClient {
         });
         return response.data ?? [];
     }
+    async listUniverses() {
+        const url = new URL("/v1/universes", this.baseUrl);
+        const response = await this.requestJson(url.toString(), {
+            method: "GET",
+        });
+        return response.data ?? [];
+    }
+    async fetchUniverse(id) {
+        const normalizedId = String(id ?? "").trim();
+        if (!normalizedId) {
+            return null;
+        }
+        const url = new URL(`/v1/universes/${encodeURIComponent(normalizedId)}`, this.baseUrl);
+        const response = await this.requestJson(url.toString(), {
+            method: "GET",
+        });
+        return response.data ?? null;
+    }
+    async fetchUniverseBatch(ids) {
+        const normalizedIds = ids
+            .map((id) => String(id ?? "").trim())
+            .filter(Boolean);
+        if (normalizedIds.length === 0) {
+            return {};
+        }
+        const url = new URL("/v1/universes/batch", this.baseUrl);
+        const response = await this.requestJson(url.toString(), {
+            method: "POST",
+            body: JSON.stringify({ ids: normalizedIds }),
+        });
+        return response.data ?? {};
+    }
     async fetchKlinesBatch(symbols, params = {}) {
         if (symbols.length === 0) {
             return { data: {} };

package/dist/services/tickflow-universe-service.d.ts

@@ -0,0 +1,26 @@
+import { TickFlowClient } from "./tickflow-client.js";
+import { UniverseMembershipRepository } from "../storage/repositories/universe-membership-repo.js";
+import { UniverseRepository } from "../storage/repositories/universe-repo.js";
+export interface TickFlowIndustryProfile {
+    sectorPath: string | null;
+    sw1Name: string | null;
+    sw2Name: string | null;
+    sw3Name: string | null;
+    sw1UniverseId: string | null;
+    sw2UniverseId: string | null;
+    sw3UniverseId: string | null;
+    industryCode: string | null;
+}
+export declare class TickFlowUniverseService {
+    private readonly client;
+    private readonly universeRepository;
+    private readonly membershipRepository;
+    private catalog;
+    constructor(client: TickFlowClient, universeRepository: UniverseRepository, membershipRepository: UniverseMembershipRepository);
+    resolveIndustryProfile(symbol: string): Promise<TickFlowIndustryProfile | null>;
+    listUniverseSymbols(universeId: string): Promise<string[]>;
+    private ensureCatalog;
+    private loadCatalogFromRepositories;
+    private syncCatalogFromTickFlow;
+    private fetchUniverseDetails;
+}

package/dist/services/tickflow-universe-service.js

@@ -0,0 +1,213 @@
+import { formatChinaDateTime } from "../utils/china-time.js";
+const UNIVERSE_BATCH_SIZE = 50;
+const UNIVERSE_CACHE_REFRESH_MS = 24 * 60 * 60 * 1000;
+const SHENWAN_UNIVERSE_PATTERN = /^CN_Equity_(SW[123])_(\d{6})$/;
+export class TickFlowUniverseService {
+    client;
+    universeRepository;
+    membershipRepository;
+    catalog = null;
+    constructor(client, universeRepository, membershipRepository) {
+        this.client = client;
+        this.universeRepository = universeRepository;
+        this.membershipRepository = membershipRepository;
+    }
+    async resolveIndustryProfile(symbol) {
+        const catalog = await this.ensureCatalog();
+        const universeIds = catalog.membershipUniverseIdsBySymbol.get(symbol) ?? [];
+        if (universeIds.length === 0) {
+            return null;
+        }
+        const summaries = universeIds
+            .map((id) => catalog.summariesById.get(id))
+            .filter((item) => item != null)
+            .map((summary) => ({
+            summary,
+            shenwan: parseShenwanUniverse(summary),
+        }))
+            .filter((item) => item.shenwan != null);
+        if (summaries.length === 0) {
+            return null;
+        }
+        const sw1 = summaries.find((item) => item.shenwan.level === "SW1") ?? null;
+        const sw2 = summaries.find((item) => item.shenwan.level === "SW2") ?? null;
+        const sw3 = summaries.find((item) => item.shenwan.level === "SW3") ?? null;
+        const names = [sw1?.shenwan.label, sw2?.shenwan.label, sw3?.shenwan.label]
+            .filter((value) => Boolean(value));
+        return {
+            sectorPath: names.length > 0 ? names.join("-") : null,
+            sw1Name: sw1?.shenwan.label ?? null,
+            sw2Name: sw2?.shenwan.label ?? null,
+            sw3Name: sw3?.shenwan.label ?? null,
+            sw1UniverseId: sw1?.summary.id ?? null,
+            sw2UniverseId: sw2?.summary.id ?? null,
+            sw3UniverseId: sw3?.summary.id ?? null,
+            industryCode: sw3?.shenwan.code ?? sw2?.shenwan.code ?? sw1?.shenwan.code ?? null,
+        };
+    }
+    async listUniverseSymbols(universeId) {
+        const catalog = await this.ensureCatalog();
+        return [...(catalog.symbolsByUniverseId.get(universeId) ?? [])];
+    }
+    async ensureCatalog(force = false) {
+        if (!force && this.catalog && Date.now() - this.catalog.syncedAtTs < UNIVERSE_CACHE_REFRESH_MS) {
+            return this.catalog;
+        }
+        const localCatalog = await this.loadCatalogFromRepositories();
+        if (!force && localCatalog && Date.now() - localCatalog.syncedAtTs < UNIVERSE_CACHE_REFRESH_MS) {
+            this.catalog = localCatalog;
+            return localCatalog;
+        }
+        try {
+            const syncedCatalog = await this.syncCatalogFromTickFlow();
+            this.catalog = syncedCatalog;
+            return syncedCatalog;
+        }
+        catch (error) {
+            if (localCatalog) {
+                console.warn(`[tickflow-universe] remote sync failed, falling back to local cache: ${toErrorMessage(error)}`);
+                this.catalog = localCatalog;
+                return localCatalog;
+            }
+            throw error;
+        }
+    }
+    async loadCatalogFromRepositories() {
+        const [summaries, memberships] = await Promise.all([
+            this.universeRepository.list(),
+            this.membershipRepository.list(),
+        ]);
+        if (summaries.length === 0 || memberships.length === 0) {
+            return null;
+        }
+        return buildCachedCatalog(summaries, memberships);
+    }
+    async syncCatalogFromTickFlow() {
+        const summaries = await this.client.listUniverses();
+        if (summaries.length === 0) {
+            throw new Error("TickFlow universe list is empty");
+        }
+        const details = await this.fetchUniverseDetails(summaries);
+        const syncedAt = formatChinaDateTime();
+        const universeRows = summaries.map((summary) => details[summary.id] ?? summary);
+        const memberships = universeRows.flatMap((item) => toUniverseMembershipEntries(item));
+        if (memberships.length === 0) {
+            throw new Error("TickFlow universe detail sync returned no membership rows");
+        }
+        await Promise.all([
+            this.universeRepository.replaceAll(universeRows, syncedAt),
+            this.membershipRepository.replaceAll(memberships),
+        ]);
+        const cached = buildCachedCatalog(universeRows.map((item) => ({
+            id: item.id,
+            name: item.name,
+            description: item.description ?? null,
+            region: item.region,
+            category: item.category,
+            symbolCount: Math.max(0, Math.trunc(Number(item.symbol_count ?? 0))),
+            syncedAt,
+        })), memberships);
+        this.catalog = cached;
+        return cached;
+    }
+    async fetchUniverseDetails(summaries) {
+        const details = {};
+        const ids = summaries.map((summary) => summary.id);
+        for (let index = 0; index < ids.length; index += UNIVERSE_BATCH_SIZE) {
+            const chunk = ids.slice(index, index + UNIVERSE_BATCH_SIZE);
+            const result = await this.client.fetchUniverseBatch(chunk);
+            for (const [id, detail] of Object.entries(result)) {
+                details[id] = detail;
+            }
+            const missingIds = chunk.filter((id) => details[id] == null);
+            for (const missingId of missingIds) {
+                const detail = await this.client.fetchUniverse(missingId);
+                if (detail) {
+                    details[missingId] = detail;
+                }
+            }
+        }
+        return details;
+    }
+}
+function buildCachedCatalog(summaries, memberships) {
+    const summariesById = new Map(summaries.map((item) => [item.id, item]));
+    const membershipUniverseIdsBySymbol = new Map();
+    const symbolsByUniverseId = new Map();
+    for (const membership of memberships) {
+        pushUnique(membershipUniverseIdsBySymbol, membership.symbol, membership.universeId);
+        pushUnique(symbolsByUniverseId, membership.universeId, membership.symbol);
+    }
+    const syncedAtTs = summaries.reduce((latest, item) => {
+        const timestamp = Date.parse(toIsoLikeTimestamp(item.syncedAt));
+        return Number.isFinite(timestamp) ? Math.max(latest, timestamp) : latest;
+    }, 0);
+    return {
+        summariesById,
+        membershipUniverseIdsBySymbol,
+        symbolsByUniverseId,
+        syncedAtTs,
+    };
+}
+function parseShenwanUniverse(summary) {
+    const match = summary.id.match(SHENWAN_UNIVERSE_PATTERN);
+    if (!match) {
+        return null;
+    }
+    const [, level = "", code = ""] = match;
+    const label = extractUniverseLabel(summary.name, summary.description);
+    if (!label) {
+        return null;
+    }
+    return {
+        level: level,
+        code,
+        label,
+    };
+}
+function extractUniverseLabel(name, description) {
+    const descriptionLabel = String(description ?? "")
+        .replace(/^申万[123]级行业[:：]\s*/, "")
+        .trim();
+    if (descriptionLabel) {
+        return descriptionLabel;
+    }
+    const nameLabel = String(name ?? "")
+        .replace(/^SW[123]/, "")
+        .trim();
+    return nameLabel || null;
+}
+function toUniverseMembershipEntries(item) {
+    if (!("symbols" in item) || !Array.isArray(item.symbols)) {
+        return [];
+    }
+    return item.symbols
+        .map((symbol) => String(symbol ?? "").trim())
+        .filter(Boolean)
+        .map((symbol) => ({
+        universeId: item.id,
+        symbol,
+    }));
+}
+function pushUnique(map, key, value) {
+    const existing = map.get(key);
+    if (existing) {
+        if (!existing.includes(value)) {
+            existing.push(value);
+        }
+        return;
+    }
+    map.set(key, [value]);
+}
+function toIsoLikeTimestamp(value) {
+    const text = value.trim();
+    if (!text) {
+        return text;
+    }
+    return /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(text)
+        ? `${text.replace(" ", "T")}+08:00`
+        : text;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/services/watchlist-profile-service.d.ts

@@ -1,6 +1,7 @@
 import { AnalysisService } from "./analysis-service.js";
 import type { MxSearchDocument } from "../types/mx-search.js";
 import { MxApiService } from "./mx-search-service.js";
+import { TickFlowUniverseService } from "./tickflow-universe-service.js";
 export interface WatchlistProfile {
     sector: string | null;
     themes: string[];
@@ -8,13 +9,15 @@ export interface WatchlistProfile {
     themeUpdatedAt: string | null;
 }
 export declare class WatchlistProfileService {
+    private readonly tickFlowUniverseService;
     private readonly mxApiService;
     private readonly analysisService;
-    constructor(mxApiService: MxApiService, analysisService: AnalysisService);
+    constructor(tickFlowUniverseService: TickFlowUniverseService | null, mxApiService: MxApiService, analysisService: AnalysisService);
     resolve(symbol: string, companyName: string, updatedAt: string): Promise<WatchlistProfile>;
 }
 export declare function buildBoardNewsQuery(profile: {
     sector: string | null;
     themes: string[];
 }): string | null;
+export declare function extractSectorKeywords(sector: string | null | undefined): string[];
 export declare function formatWatchlistProfileDocuments(documents: MxSearchDocument[]): string;

package/dist/services/watchlist-profile-service.js

@@ -2,46 +2,58 @@ import { parseWatchlistProfileExtraction } from "../analysis/parsers/watchlist-p
 import { buildWatchlistProfileExtractionUserPrompt, WATCHLIST_PROFILE_EXTRACTION_SYSTEM_PROMPT, } from "../prompts/analysis/index.js";
 const MAX_PROFILE_DOCUMENTS = 8;
 export class WatchlistProfileService {
+    tickFlowUniverseService;
     mxApiService;
     analysisService;
-    constructor(mxApiService, analysisService) {
+    constructor(tickFlowUniverseService, mxApiService, analysisService) {
+        this.tickFlowUniverseService = tickFlowUniverseService;
         this.mxApiService = mxApiService;
         this.analysisService = analysisService;
     }
     async resolve(symbol, companyName, updatedAt) {
         const themeQuery = buildThemeQuery(companyName, symbol);
+        const industryProfile = this.tickFlowUniverseService
+            ? await this.tickFlowUniverseService.resolveIndustryProfile(symbol)
+                .catch((error) => {
+                console.warn(`[watchlist-profile] tickflow universe lookup skipped for ${symbol}: ${toErrorMessage(error)}`);
+                return null;
+            })
+            : null;
         const mxConfigError = this.mxApiService.getConfigurationError();
-        if (mxConfigError) {
-            throw new Error(mxConfigError);
-        }
         const llmConfigError = this.analysisService.getConfigurationError();
-        if (llmConfigError) {
-            throw new Error(llmConfigError);
-        }
-        const documents = (await this.mxApiService.search(themeQuery)).slice(0, MAX_PROFILE_DOCUMENTS);
-        if (documents.length === 0) {
-            return {
-                sector: null,
-                themes: [],
-                themeQuery,
-                themeUpdatedAt: updatedAt,
-            };
+        const canUseMx = !mxConfigError && !llmConfigError;
+        let parsedProfile = null;
+        if (canUseMx) {
+            try {
+                const documents = (await this.mxApiService.search(themeQuery)).slice(0, MAX_PROFILE_DOCUMENTS);
+                if (documents.length > 0) {
+                    const responseText = await this.analysisService.generateText(WATCHLIST_PROFILE_EXTRACTION_SYSTEM_PROMPT, buildWatchlistProfileExtractionUserPrompt({
+                        symbol,
+                        companyName,
+                        documents,
+                    }), {
+                        maxTokens: 1200,
+                        temperature: 0.1,
+                    });
+                    parsedProfile = parseWatchlistProfileExtraction(responseText);
+                    if (!parsedProfile) {
+                        throw new Error(`watchlist profile extraction returned invalid JSON for ${symbol}`);
+                    }
+                }
+            }
+            catch (error) {
+                if (!industryProfile) {
+                    throw error;
+                }
+                console.warn(`[watchlist-profile] mx profile enrichment skipped for ${symbol}: ${toErrorMessage(error)}`);
+            }
         }
-        const responseText = await this.analysisService.generateText(WATCHLIST_PROFILE_EXTRACTION_SYSTEM_PROMPT, buildWatchlistProfileExtractionUserPrompt({
-            symbol,
-            companyName,
-            documents,
-        }), {
-            maxTokens: 1200,
-            temperature: 0.1,
-        });
-        const profile = parseWatchlistProfileExtraction(responseText);
-        if (!profile) {
-            throw new Error(`watchlist profile extraction returned invalid JSON for ${symbol}`);
+        else if (!industryProfile) {
+            throw new Error(mxConfigError ?? llmConfigError ?? "watchlist profile service unavailable");
         }
         return {
-            sector: profile.sector,
-            themes: profile.themes,
+            sector: industryProfile?.sectorPath ?? parsedProfile?.sector ?? null,
+            themes: parsedProfile?.themes ?? [],
             themeQuery,
             themeUpdatedAt: updatedAt,
         };
@@ -49,7 +61,7 @@ export class WatchlistProfileService {
 }
 export function buildBoardNewsQuery(profile) {
     const keywords = [
-        String(profile.sector ?? "").trim(),
+        ...extractSectorKeywords(profile.sector),
         ...profile.themes
             .map((item) => String(item ?? "").trim())
             .filter(Boolean)
@@ -60,6 +72,17 @@ export function buildBoardNewsQuery(profile) {
     }
     return `${keywords.join(" ")} 板块 题材 最新新闻 政策 资金`;
 }
+export function extractSectorKeywords(sector) {
+    const raw = String(sector ?? "").trim();
+    if (!raw) {
+        return [];
+    }
+    const keywords = raw
+        .split(/[-/|>|→｜]/)
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return uniqueStrings(keywords.length > 0 ? keywords : [raw]);
+}
 function buildThemeQuery(companyName, symbol) {
     return `${companyName} ${symbol} 所属行业 板块 题材 概念`;
 }
@@ -74,3 +97,9 @@ export function formatWatchlistProfileDocuments(documents) {
     ].join("\n"))
         .join("\n\n");
 }
+function uniqueStrings(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/services/watchlist-service.js

@@ -160,7 +160,7 @@ export class WatchlistService {
     }
 }
 function shouldRefreshConceptBoards(item) {
-    if (!item.sector || item.themes.length === 0 || !item.themeUpdatedAt) {
+    if (!item.sector || !item.themeUpdatedAt) {
         return true;
     }
     const updatedAt = parseChinaTimestamp(item.themeUpdatedAt);

package/dist/storage/repositories/universe-membership-repo.d.ts

@@ -0,0 +1,11 @@
+import { Database } from "../db.js";
+export interface UniverseMembershipEntry {
+    universeId: string;
+    symbol: string;
+}
+export declare class UniverseMembershipRepository {
+    private readonly db;
+    constructor(db: Database);
+    list(): Promise<UniverseMembershipEntry[]>;
+    replaceAll(entries: UniverseMembershipEntry[]): Promise<void>;
+}

package/dist/storage/repositories/universe-membership-repo.js

@@ -0,0 +1,38 @@
+import { universeMembershipSchema } from "../schemas.js";
+const UNIVERSE_MEMBERSHIP_TABLE = "universe_memberships";
+export class UniverseMembershipRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async list() {
+        if (!(await this.db.hasTable(UNIVERSE_MEMBERSHIP_TABLE))) {
+            return [];
+        }
+        const rows = await this.db.tableToArray(UNIVERSE_MEMBERSHIP_TABLE);
+        return rows
+            .map((row) => ({
+            universeId: String(row.universeId ?? row.universe_id ?? "").trim(),
+            symbol: String(row.symbol ?? "").trim(),
+        }))
+            .filter((row) => row.universeId && row.symbol);
+    }
+    async replaceAll(entries) {
+        const rows = entries.map(toUniverseMembershipRow);
+        if (rows.length === 0) {
+            return;
+        }
+        if (!(await this.db.hasTable(UNIVERSE_MEMBERSHIP_TABLE))) {
+            await this.db.createTable(UNIVERSE_MEMBERSHIP_TABLE, rows, universeMembershipSchema);
+            return;
+        }
+        const table = await this.db.openTable(UNIVERSE_MEMBERSHIP_TABLE);
+        await table.add(rows, { mode: "overwrite" });
+    }
+}
+function toUniverseMembershipRow(entry) {
+    return {
+        universeId: entry.universeId,
+        symbol: entry.symbol,
+    };
+}

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

@@ -0,0 +1,17 @@
+import type { TickFlowUniverseSummary } from "../../types/tickflow.js";
+import { Database } from "../db.js";
+export interface StoredUniverseSummary {
+    id: string;
+    name: string;
+    description: string | null;
+    region: string;
+    category: string;
+    symbolCount: number;
+    syncedAt: string;
+}
+export declare class UniverseRepository {
+    private readonly db;
+    constructor(db: Database);
+    list(): Promise<StoredUniverseSummary[]>;
+    replaceAll(universes: TickFlowUniverseSummary[], syncedAt: string): Promise<void>;
+}

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

@@ -0,0 +1,62 @@
+import { universeSchema } from "../schemas.js";
+const UNIVERSE_TABLE = "universes";
+export class UniverseRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async list() {
+        if (!(await this.db.hasTable(UNIVERSE_TABLE))) {
+            return [];
+        }
+        const rows = await this.db.tableToArray(UNIVERSE_TABLE);
+        return rows
+            .map((row) => ({
+            id: String(row.id ?? "").trim(),
+            name: String(row.name ?? "").trim(),
+            description: normalizeNullableString(row.description),
+            region: String(row.region ?? "").trim(),
+            category: String(row.category ?? "").trim(),
+            symbolCount: normalizeNonNegativeInteger(row.symbolCount ?? row.symbol_count),
+            syncedAt: String(row.syncedAt ?? row.synced_at ?? "").trim(),
+        }))
+            .filter((row) => row.id && row.name);
+    }
+    async replaceAll(universes, syncedAt) {
+        const rows = universes.map((item) => toUniverseRow(item, syncedAt));
+        if (rows.length === 0) {
+            return;
+        }
+        if (!(await this.db.hasTable(UNIVERSE_TABLE))) {
+            await this.db.createTable(UNIVERSE_TABLE, rows, universeSchema);
+            return;
+        }
+        const table = await this.db.openTable(UNIVERSE_TABLE);
+        await table.add(rows, { mode: "overwrite" });
+    }
+}
+function toUniverseRow(item, syncedAt) {
+    return {
+        id: item.id,
+        name: item.name,
+        description: item.description ?? "",
+        region: item.region,
+        category: item.category,
+        symbolCount: Math.max(0, Math.trunc(Number(item.symbol_count ?? 0))),
+        syncedAt,
+    };
+}
+function normalizeNullableString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const text = value.trim();
+    return text || null;
+}
+function normalizeNonNegativeInteger(value) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric < 0) {
+        return 0;
+    }
+    return Math.trunc(numeric);
+}

package/dist/storage/schemas.d.ts

@@ -1,5 +1,7 @@
 import { Schema } from "apache-arrow";
 export declare const watchlistSchema: Schema<any>;
+export declare const universeSchema: Schema<any>;
+export declare const universeMembershipSchema: Schema<any>;
 export declare const klinesDailySchema: Schema<any>;
 export declare const klinesIntradaySchema: Schema<any>;
 export declare const indicatorsSchema: Schema<any>;

package/dist/storage/schemas.js

@@ -9,6 +9,19 @@ export const watchlistSchema = new Schema([
     new Field("themeQuery", new Utf8(), true),
     new Field("themeUpdatedAt", new Utf8(), true),
 ]);
+export const universeSchema = new Schema([
+    new Field("id", new Utf8(), false),
+    new Field("name", new Utf8(), false),
+    new Field("description", new Utf8(), true),
+    new Field("region", new Utf8(), false),
+    new Field("category", new Utf8(), false),
+    new Field("symbolCount", new Int64(), false),
+    new Field("syncedAt", new Utf8(), false),
+]);
+export const universeMembershipSchema = new Schema([
+    new Field("universeId", new Utf8(), false),
+    new Field("symbol", new Utf8(), false),
+]);
 export const klinesDailySchema = new Schema([
     new Field("symbol", new Utf8(), false),
     new Field("trade_date", new Utf8(), false),

package/dist/tools/add-stock.tool.d.ts

@@ -3,7 +3,8 @@ import { KlineService } from "../services/kline-service.js";
 import { KlinesRepository } from "../storage/repositories/klines-repo.js";
 import { IndicatorService } from "../services/indicator-service.js";
 import { IndicatorsRepository } from "../storage/repositories/indicators-repo.js";
-export declare function addStockTool(watchlistService: WatchlistService, klineService: KlineService, klinesRepository: KlinesRepository, indicatorService: IndicatorService, indicatorsRepository: IndicatorsRepository): {
+import type { TickflowApiKeyLevel } from "../config/tickflow-access.js";
+export declare function addStockTool(tickflowApiKeyLevel: TickflowApiKeyLevel, watchlistService: WatchlistService, klineService: KlineService, klinesRepository: KlinesRepository, indicatorService: IndicatorService, indicatorsRepository: IndicatorsRepository): {
     name: string;
     description: string;
     optional: boolean;

package/dist/tools/add-stock.tool.js

@@ -34,7 +34,7 @@ function parseOptionalPositiveNumber(value) {
     }
     return numeric;
 }
-export function addStockTool(watchlistService, klineService, klinesRepository, indicatorService, indicatorsRepository) {
+export function addStockTool(tickflowApiKeyLevel, watchlistService, klineService, klinesRepository, indicatorService, indicatorsRepository) {
     return {
         name: "add_stock",
         description: "Add a symbol to the watchlist with optional cost price, then fetch daily K-lines and indicators.",
@@ -65,6 +65,7 @@ export function addStockTool(watchlistService, klineService, klinesRepository, i
                 if (rows.length === 0) {
                     return [
                         ...buildAddStockPrefix(item, profileError),
+                        buildProfileSourceHint(tickflowApiKeyLevel),
                         `⚠️ 已尝试拉取 ${klineCount} 天日K，但返回数据为空`,
                     ].filter(Boolean).join("\n");
                 }
@@ -75,6 +76,7 @@ export function addStockTool(watchlistService, klineService, klinesRepository, i
                 const last = rows[rows.length - 1];
                 return [
                     ...buildAddStockPrefix(item, profileError),
+                    buildProfileSourceHint(tickflowApiKeyLevel),
                     `📊 已自动获取日K: ${rows.length} 根`,
                     `区间: ${first.trade_date} ~ ${last.trade_date}`,
                     `最新收盘: ${last.close.toFixed(2)}`,
@@ -85,6 +87,7 @@ export function addStockTool(watchlistService, klineService, klinesRepository, i
                 const message = error instanceof Error ? error.message : String(error);
                 return [
                     ...buildAddStockPrefix(item, profileError),
+                    buildProfileSourceHint(tickflowApiKeyLevel),
                     `⚠️ 自动拉取 ${klineCount} 天日K失败: ${message}`,
                 ].filter(Boolean).join("\n");
             }
@@ -114,6 +117,12 @@ function formatWatchlistProfileWarning(profileError) {
     }
     return `⚠️ 行业分类/概念板块获取失败: ${profileError}`;
 }
+function buildProfileSourceHint(tickflowApiKeyLevel) {
+    if (tickflowApiKeyLevel !== "free") {
+        return null;
+    }
+    return "ℹ️ 当前 TickFlow API Key Level 为 Free，标的池不可用，行业分类当前走妙想链路。";
+}
 function formatAddStockFailure(symbol, error) {
     const message = error instanceof Error ? error.message : String(error);
     if (!symbol) {

package/dist/tools/query-database.tool.js

@@ -5,6 +5,12 @@ const TABLE_ALIASES = {
     watchlists: "watchlist",
     自选: "watchlist",
     自选股: "watchlist",
+    universes: "universes",
+    universe: "universes",
+    标的池: "universes",
+    universe_memberships: "universe_memberships",
+    universe_members: "universe_memberships",
+    标的池成员: "universe_memberships",
     klines: "klines_daily",
     kline: "klines_daily",
     klines_daily: "klines_daily",