gangtise-openapi-cli 0.49.0 → 0.51.0

package/dist/src/core/endpoints.js

@@ -390,6 +390,13 @@ const ENDPOINT_DEFS = {
         kind: "json",
         description: "List constituent securities of a sector",
     },
+    "reference.index-weight": {
+        method: "POST",
+        path: "/application/open-quote/index/constituent-weight",
+        kind: "json",
+        description: "List index constituents with their weights (%) on one trading date",
+        expects: "list",
+    },
     "quote.day-kline": {
         method: "POST",
         path: "/application/open-quote/kline/daily",
@@ -439,6 +446,13 @@ const ENDPOINT_DEFS = {
         description: "Query A-share daily fund flow (SH/SZ/BJ; small/medium/large/xlarge orders + main net inflow)",
         expects: "list",
     },
+    "quote.sector-fund-flow": {
+        method: "POST",
+        path: "/application/open-quote/fund-flow/sector-daily",
+        kind: "json",
+        description: "Query sector daily fund flow (constituents summed, SH/SZ/BJ only)",
+        expects: "list",
+    },
     "fundamental.income-statement": {
         method: "POST",
         path: "/application/open-fundamental/financial-report/income-statement/accumulated",
@@ -915,6 +929,18 @@ const ENDPOINT_DEFS = {
         pagination: { enabled: true, maxPageSize: 20 },
         retry: "no-replay",
     },
+    "ai.expert-intel.list": {
+        method: "POST",
+        path: "/application/open-insight/expertIntel/getList",
+        kind: "json",
+        description: "List AI expert intel (takeaways distilled from expert meetings and minutes)",
+        billing: { per: "row", price: 20 },
+        pagination: { enabled: true, maxPageSize: 50 },
+        rowId: "intelId",
+        rowIdUnverified: true,
+        retry: "no-replay",
+        expects: "list",
+    },
     "ai.management-discuss-announcement": {
         method: "POST",
         path: "/application/open-ai/management-discuss/from-announcement",
@@ -1096,6 +1122,13 @@ const ENDPOINT_DEFS = {
         pagination: { enabled: true, maxPageSize: 50, maxWindow: 10000 },
         rowId: "msgId",
     },
+    "vault.wechat-message.download": {
+        method: "GET",
+        path: "/application/open-vault/wechatgroupmsg/download/file",
+        kind: "download",
+        description: "Download the file of a WeChat group message (document / image / audio / video)",
+        fileOnSuccess: true,
+    },
     "vault.wechat-chatroom.list": {
         method: "POST",
         path: "/application/open-vault/wechatgroupmsg/chatroomId",
@@ -1151,6 +1184,35 @@ const ENDPOINT_DEFS = {
         itemFailures: true,
         description: "Remove securities from a stock pool",
     },
+    "vault.stock-note.list": {
+        method: "POST",
+        path: "/application/open-vault/stock-pool/getNoteList",
+        kind: "json",
+        description: "List your stock notes (all, by security, or by note ID)",
+        pagination: { enabled: true, maxPageSize: 50 },
+        rowId: "stockNoteId",
+    },
+    "vault.stock-note.add": {
+        method: "POST",
+        path: "/application/open-vault/stock-pool/addNote",
+        kind: "json",
+        retry: "no-replay",
+        description: "Add a stock note linked to 1-50 securities",
+    },
+    "vault.stock-note.update": {
+        method: "POST",
+        path: "/application/open-vault/stock-pool/updateNote",
+        kind: "json",
+        description: "Replace the content of a stock note",
+    },
+    "vault.stock-note.delete": {
+        method: "POST",
+        path: "/application/open-vault/stock-pool/deleteNote",
+        kind: "json",
+        destructive: { warning: "删除笔记会删掉整条笔记（含它与全部关联证券的关系），不可恢复；先用 'gangtise vault stock-note-list --note-id <id>' 核对内容。" },
+        itemFailures: true,
+        description: "Delete stock notes",
+    },
     "alternative.edb-search": {
         method: "POST",
         path: "/application/open-alternative/EDB/search",

package/dist/src/core/errors.js

@@ -48,16 +48,16 @@ const ERROR_HINTS = {
     "100003": "msg 已指明字段名或取值范围时直接按 msg 改；msg 只说「参数值非法」时多为枚举参数拼写错误（如 --source / --question-category / --answer-important），对照命令 --help 列出的合法值检查。",
     "100004": "检查 --size / --from 是否为非负数且未超单页上限。",
     "100005": "对照命令 --help 列出的合法取值检查。",
-    "100006": "缩短日期范围或调小 --size / --limit（list 类端点单页上限为 50，CLI 自动翻页，直发接口时要自己遵守）；indicator cross-section / time-series 撞此码是单次单元格数超 30000（截面=证券数×指标数，时序=证券数或指标数×日期数），按这个乘积拆批重跑；fund 命令不分页，撞此码是单次超过 10000 行，减少 --security 只数或缩短日期区间分批查。",
+    "100006": "缩短日期范围或调小 --size / --limit（list 类端点单页上限为 50，CLI 自动翻页，直发接口时要自己遵守）；indicator cross-section / time-series 撞此码是单次单元格数超 30000（截面=证券数×指标数，时序=证券数或指标数×日期数），按这个乘积拆批重跑；fund 命令不分页，撞此码是单次超过 10000 行，减少 --security 只数或缩短日期区间分批查；quote sector-fund-flow 撞此码是计算量超限，缩短日期区间、减少 --sector 或 --field（调小 --limit 无效）。",
     "110001": "看参数名：`--*-date` 用 YYYY-MM-DD，`--*-time` 用 \"YYYY-MM-DD HH:mm:ss\"（`ai knowledge-batch` 的 --start-time/--end-time 收时间戳或 datetime，CLI 统一转 13 位毫秒）。",
     "110002": "起始晚于结束——检查 --start-date/--end-date 或 --start-time/--end-time 的先后。",
     "110003": "查询时间超出本账号的数据权限范围——把日期移进范围内（整个区间都早于下界时缩短窗口无用），或联系客户经理开通更长历史。",
     "120001": "用 `gangtise reference securities-search` 确认代码与后缀（如 600519.SH / 00700.HK）。",
     "130001": "未找到数据——先核对查询条件；EDE 指标端点此码也可能是未开通该指标权限，仍失败联系客户经理。",
-    "130002": "确认 ID 有效且本账号可见（云盘的文件 / 文件夹 ID 用 `vault drive-folder-list` 核对；删除类命令收到此码可能是目标已被删掉）；下载类还需检查 --file-type 取值是否合法。",
-    "130003": "资源未生成或该条记录未附带文件——换一条有附件的记录（列表里 hasAttachment/hasFile 为 true 的），或稍后再试。",
+    "130002": "确认 ID 有效且本账号可见（云盘的文件 / 文件夹 ID 用 `vault drive-folder-list` 核对，笔记 ID 用 `vault stock-note-list` 核对；删除类命令收到此码可能是目标已被删掉）；下载类还需检查 --file-type 取值是否合法。",
+    "130003": "资源未生成或该条记录未附带文件——换一条有附件的记录（列表里 hasAttachment/hasFile 为 true 的），或稍后再试；`vault wechat-message-download` 收到此码是消息不存在、本账号无权访问或文件已不可用，重试不会变。",
     "130004": "下载 ID 需为数字，检查该命令的 --*-id 参数是否传对。",
-    "130005": "对照命令 --help 检查 --file-type / --content-type 取值。",
+    "130005": "对照命令 --help 检查 --file-type / --content-type 取值；`vault wechat-message-download` 收到此码是该消息为 text / url、没有文件——只有 document / image / audio / video 消息可下载。",
     "140001": "稍后用对应 *-check 命令查询。",
     "140002": "终态失败，立即重试同一请求不会变。msg 指向参数（EDE 的指标参数名/枚举以 indicator search 的 parameterList 为准）就改参数重新提交；msg 是「业务处理失败」则与参数无关，稍后再试，持续出现请带 trace 报障。",
     "210001": "换一篇，或改用 list 取正文摘要。",
@@ -97,11 +97,24 @@ const ERROR_HINTS = {
 };
 function distinctFailureShapes(message) {
     const byCode = new Map();
+    let current;
     for (const clause of message.split(/[;；]/)) {
-        const m = /指标\s+(\S+)\s+(不支持参数|缺少必填参数)[:：]?\s*(\S+)/.exec(clause);
-        if (!m)
-            continue;
-        const [, code, kind, key] = m;
+        let code, kind, key;
+        const old = /指标\s+(\S+)\s+(不支持参数|缺少必填参数)[:：]?\s*(\S+)/.exec(clause);
+        if (old) {
+            [, code, kind, key] = old;
+        }
+        else {
+            const head = /^\s*([^\s:：]+)(?:\s*\(指标代码\s*[^)]*\))?\s*[:：]/.exec(clause);
+            if (head)
+                current = head[1];
+            const body = /不支持参数\s*(\S+)|必填参数\s*(\S+)\s*不能为空/.exec(clause);
+            if (!body || !current)
+                continue;
+            code = current;
+            kind = body[1] ? "不支持参数" : "缺少必填参数";
+            key = body[1] ?? body[2];
+        }
         let shape = byCode.get(code);
         if (!shape) {
             shape = new Set();
@@ -113,36 +126,37 @@ function distinctFailureShapes(message) {
         return 1;
     return new Set([...byCode.values()].map((shape) => [...shape].sort().join("|"))).size;
 }
+const missing = (keys) => new RegExp(`缺少必填参数[:：]?\\s*(?:${keys})|必填参数\\s*(?:${keys})\\s*不能为空`);
 const MESSAGE_HINTS = [
     {
         codes: ["100001", "100003"],
-        match: /不支持参数\s*(?:tradeDate|reportDate)|缺少必填参数[:：]?\s*(?:tradeDate|reportDate)/,
+        match: new RegExp(`不支持参数\\s*(?:tradeDate|reportDate)|${missing("tradeDate|reportDate").source}`),
         when: (message) => distinctFailureShapes(message) > 1,
-        hint: "🔴 **这条报错涉及多个指标，而且它们失败的方式不同**——同一个改法套不到全部，按 msg 里每个指标各自说的话分别处理：msg 里对某个指标说「不支持参数 X; 缺少必填参数 Y」= 把 X 换成 Y（`--indicator-param \"<该指标code>:Y=...\"`）；只说「不支持参数 X」而没说缺什么 = 该指标一个日期都不要，给它加 `--indicator-param \"<该指标code>:\"`（冒号后留空）；只说「缺少必填参数 Y」= 补上 Y。**最省事的办法是把这批指标拆成几次单独查**，那样每条报错只对应一个指标，提示也能给准。以 `indicator search --keyword <指标code> --format json` 的 parameterList 为准。",
+        hint: "🔴 **这条报错涉及多个指标，而且它们失败的方式不同**——同一个改法套不到全部，按 msg 里每个指标各自说的话分别处理：msg 里对某个指标说「不支持参数 X; 必填参数 Y 不能为空」（旧写法「缺少必填参数 Y」）= 把 X 换成 Y（`--indicator-param \"<该指标code>:Y=...\"`）；只说「不支持参数 X」而没说缺什么 = 该指标一个日期都不要，给它加 `--indicator-param \"<该指标code>:\"`（冒号后留空）；只说 Y 必填 = 补上 Y。**最省事的办法是把这批指标拆成几次单独查**，那样每条报错只对应一个指标，提示也能给准。以 `indicator search --keyword <指标code> --format json` 的 parameterList 为准。",
     },
     {
         codes: ["100001", "100003"],
-        match: /缺少必填参数[:：]?\s*reportDate/,
+        match: missing("reportDate"),
         when: (message) => distinctFailureShapes(message) <= 1,
         hint: "报错点名的指标要的是 reportDate（报告期），不是 --date 下发的 tradeDate。给每个被点名的指标各补一条 --indicator-param \"<指标code>:reportDate=YYYY-MM-DD\"（screener 用 \"F1:reportDate=...\"），--date 仍要保留——补上后 CLI 就不再为该指标注入 tradeDate。⚠️ 少数指标两个日期都要（如 div_cash_yld），补完若再报缺 tradeDate，就把 tradeDate 也显式传上。**以 `indicator search` 返回的 parameterList 为准，别按 code 前缀推断**。",
     },
     {
         codes: ["100001", "100003"],
         match: /不支持参数\s*(?:tradeDate|reportDate)/,
-        also: /缺少必填参数[:：]?\s*tradeDate/,
+        also: missing("tradeDate"),
         when: (message) => distinctFailureShapes(message) <= 1,
         hint: "服务端在同一句里**已经点名了两边**：一个键不该出现，另一个键缺了——把前者换成后者即可，别再往里加键。多半是两个日期键写反了：删掉 --indicator-param 里被拒的那个，改成 msg 里说缺的那个（如 --indicator-param \"<指标code>:tradeDate=YYYY-MM-DD\"，screener 用 \"F1:tradeDate=...\"）。⚠️ 别在这一步用 --indicator-param \"<指标code>:\"（「不要日期」的写法）——服务端明说了它要一个日期，那样只会撞下一个报错。",
     },
     {
         codes: ["100001", "100003"],
         match: /不支持参数\s*(?:tradeDate|reportDate)/,
-        notMatch: /缺少必填参数[:：]?\s*(?:reportDate|tradeDate)/,
+        notMatch: missing("reportDate|tradeDate"),
         when: (message) => distinctFailureShapes(message) <= 1,
         hint: "服务端只说这个键不该出现，**没说该换成哪个**——别照着「改用 reportDate」做，那多半同样被拒。报错点名的指标，其 parameterList 里没有 --date 下发的那个日期键，给每个被点名的指标各加一条 --indicator-param \"<指标code>:\"（冒号后留空）声明「本指标不要查询日期」即可，它与真实参数可以共存。跑 `indicator search --keyword <指标code> --format json` 确认还缺什么：parameterList 为空就只加这一条；还列了 fiscalYear 之类的就连同 --indicator-param \"<指标code>:fiscalYear=2025\" 一起给。screener 上是同一个写法，只是按变量写：--indicator-param \"F1:\"。",
     },
     {
         codes: ["100001", "100003"],
-        match: /缺少必填参数[:：]?\s*tradeDate/,
+        match: missing("tradeDate"),
         when: (message) => distinctFailureShapes(message) <= 1,
         hint: "--date 的 tradeDate 这次没有下发——你为该指标传了 reportDate/tradeDate，或者用了 --indicator-param \"<指标code>:\" 这个「不要日期」的写法，两者都会关掉自动注入。对症改：如果这个指标两个日期都必填（如 div_cash_yld），把 tradeDate 也显式传上 --indicator-param \"<指标code>:tradeDate=YYYY-MM-DD\"（screener 用 \"F1:tradeDate=...\"）；如果是空冒号那条加错了指标，删掉它即可。",
     },

package/dist/src/core/etfComponents.js

@@ -3,6 +3,7 @@ import { normalizeRows } from "./normalize.js";
 import { PAGE_CONCURRENCY, runWithConcurrency } from "./transport.js";
 const PRICE_TOLERANCE = 0.0005;
 const agrees = (close, price) => price > 0 && Math.abs(close - price) / price <= PRICE_TOLERANCE;
+const CHANGE_TOLERANCE = 0.005;
 const QUOTABLE = /^(\d{6}\.(SH|SZ|BJ)|\d{5}\.HK|[A-Z][A-Z0-9.]*\.(O|N|A))$/;
 const QUOTE_BATCH = 500;
 const CLOSES_WINDOW_DAYS = 10;
@@ -31,7 +32,9 @@ async function candidatesFor(name, lookup) {
         const bySuffix = (await Promise.all(["O", "N"].map((suffix) => lookup.search(`${key}.${suffix}`))))
             .flatMap((rows) => toCandidates(rows))
             .filter((c) => ticker(c.code) === key);
-        exact.push(...bySuffix);
+        for (const c of bySuffix)
+            if (!exact.some((e) => e.code === c.code))
+                exact.push(c);
     }
     const prefix = base(key).length >= 2 ? found.filter((c) => !exact.includes(c) && base(c.name).startsWith(base(key))) : [];
     return [...exact, ...prefix.map((c) => ({ ...c, prefix: true }))];
@@ -60,7 +63,7 @@ function byPrice(row, candidates, prices, etf, unchecked) {
             return undefined;
         const matched = tier.filter((c) => prices.get(c.code)?.some((p) => agrees(close, p)));
         if (matched.length)
-            return narrow(matched, etf);
+            return matched;
     }
     return undefined;
 }
@@ -124,59 +127,133 @@ export async function fillComponentCodes(rows, lookup) {
     const pending = rows.filter(needsCode);
     const names = [...new Set(pending.map((r) => r.componentName))];
     const candidates = new Map();
+    const failed = new Set();
     await runWithConcurrency(names, PAGE_CONCURRENCY, async (name) => {
-        candidates.set(name, await candidatesFor(name, lookup).catch(() => []));
+        try {
+            candidates.set(name, await candidatesFor(name, lookup));
+        }
+        catch {
+            candidates.set(name, []);
+            failed.add(name);
+        }
     });
     const quotable = [...new Set([...candidates.values()].flat().filter((c) => ["stock", "dr"].includes(c.category) && QUOTABLE.test(c.code)).map((c) => c.code))];
     const prices = new Map((await runWithConcurrency(inBatches(quotable, QUOTE_BATCH), PAGE_CONCURRENCY, (batch) => splitting(batch, (codes) => lookup.quotes(codes)))).flatMap((quoted) => [...quoted]));
     const isQuotable = (c) => ["stock", "dr"].includes(c.category) && QUOTABLE.test(c.code);
+    const candidatesOf = (row) => candidates.get(row.componentName) ?? [];
+    const marketsOf = (listed) => new Set(listed.map((c) => market(c.code)));
     const codes = new Map();
+    const tentative = new Map();
     const etfs = new Map();
     const place = (row, code, etf) => {
         codes.set(row, code);
+        tentative.delete(row);
         if (code)
             etf.used.add(code);
     };
+    const settle = (row, matched, etf) => {
+        if (marketsOf(matched).size > 1)
+            tentative.set(row, matched);
+        else
+            place(row, narrow(matched, etf), etf);
+    };
+    const unverified = new Map();
     for (const fundCode of new Set(pending.map((r) => r.fundCode))) {
         const own = pending.filter((r) => r.fundCode === fundCode);
         const etf = { exchange: exchange(String(fundCode)), used: new Set() };
         etfs.set(fundCode, { own, etf });
         for (const row of own) {
-            const code = byPrice(row, candidates.get(row.componentName) ?? [], prices, etf, isQuotable);
-            if (code !== undefined)
-                place(row, code, etf);
+            const matched = byPrice(row, candidatesOf(row), prices, etf, isQuotable);
+            if (!matched)
+                continue;
+            const held = marketsOf(matched);
+            if (held.size === 1 && candidatesOf(row).some((c) => isQuotable(c) && !held.has(market(c.code))))
+                unverified.set(row, matched);
+            else
+                settle(row, matched, etf);
         }
     }
-    const open = (own) => own.filter((r) => !codes.has(r) && typeof r.close === "number" && (candidates.get(r.componentName) ?? []).some(isQuotable));
+    const open = (own) => own.filter((r) => !codes.has(r) && typeof r.close === "number" && candidatesOf(r).some(isQuotable));
     const lagging = [...etfs.values()].filter(({ own }) => open(own).length);
+    const history = new Map();
     if (lagging.length && lookup.closes) {
-        const wanted = [...new Set(lagging.flatMap(({ own }) => own.flatMap((r) => (candidates.get(r.componentName) ?? []).filter(isQuotable).map((c) => c.code))))];
+        const wanted = [...new Set(lagging.flatMap(({ own }) => own.flatMap((r) => candidatesOf(r).filter(isQuotable).map((c) => c.code))))];
         const end = beijingDateString(new Date());
         const start = beijingDateString(new Date(Date.now() - CLOSES_WINDOW_DAYS * 86_400_000));
-        const history = new Map((await runWithConcurrency(inBatches(wanted, CLOSES_BATCH), PAGE_CONCURRENCY, (batch) => splitting(batch, (codes) => lookup.closes(codes, start, end)))).flatMap((part) => [...part]));
+        for (const part of await runWithConcurrency(inBatches(wanted, CLOSES_BATCH), PAGE_CONCURRENCY, (batch) => splitting(batch, (codes) => lookup.closes(codes, start, end)))) {
+            for (const [code, series] of part)
+                history.set(code, series);
+        }
+    }
+    const mayBe = (row, c) => !history.has(c.code) || history.get(c.code).some(([, close]) => agrees(row.close, close));
+    for (const { own, etf } of etfs.values()) {
+        for (const row of own) {
+            const matched = unverified.get(row);
+            if (!matched)
+                continue;
+            const held = marketsOf(matched);
+            const contested = lookup.closes !== undefined && candidatesOf(row).some((c) => isQuotable(c) && !etf.used.has(c.code) && !held.has(market(c.code)) && mayBe(row, c));
+            if (!contested && matched.every((c) => !etf.used.has(c.code)))
+                settle(row, matched, etf);
+            else
+                tentative.set(row, matched);
+        }
+    }
+    if (lagging.length && lookup.closes) {
         for (const { own, etf } of lagging) {
             const dates = listDates(own, candidates, history);
             const onDate = closesOn(dates, history);
             for (const row of open(own)) {
-                const unchecked = (c) => isQuotable(c) && (history.get(c.code)?.some(([, close]) => agrees(row.close, close)) ?? true);
-                const code = byPrice(row, candidates.get(row.componentName) ?? [], onDate, etf, unchecked);
-                if (code !== undefined)
-                    place(row, code, etf);
+                const unchecked = (c) => isQuotable(c) && mayBe(row, c);
+                const matched = byPrice(row, candidatesOf(row), onDate, etf, unchecked);
+                if (matched)
+                    settle(row, matched, etf);
             }
         }
     }
+    for (const { own, etf } of etfs.values()) {
+        for (const row of own) {
+            const change = row.pctChange;
+            if (codes.has(row) || typeof change !== "number" || typeof row.close !== "number")
+                continue;
+            const close = row.close;
+            const pool = candidatesOf(row).filter((c) => !etf.used.has(c.code));
+            if (!pool.length || !pool.every((c) => isQuotable(c) && history.has(c.code)))
+                continue;
+            const atClose = (c) => history.get(c.code).filter(([, price]) => agrees(close, price));
+            const hit = pool.filter((c) => atClose(c).some(([, , moved]) => moved !== undefined && Math.abs(moved - change) <= CHANGE_TOLERANCE));
+            const unknown = pool.some((c) => !hit.includes(c) && atClose(c).some(([, , moved]) => moved === undefined));
+            if (!hit.length || unknown || marketsOf(hit).size > 1)
+                continue;
+            const code = narrow(hit, etf);
+            if (code)
+                place(row, code, etf);
+        }
+    }
     for (const { own, etf } of etfs.values()) {
         const markets = new Set([...etf.used].map(market));
+        let undecided = own.some((r) => failed.has(r.componentName));
         for (const r of own) {
-            const held = new Set((candidates.get(r.componentName) ?? []).filter((c) => !c.prefix).map((c) => market(c.code)));
-            if (held.size === 1)
+            if (codes.get(r))
+                continue;
+            const held = marketsOf(candidatesOf(r).filter((c) => !etf.used.has(c.code) && (typeof r.close !== "number" || mayBe(r, c))));
+            if (held.size > 1)
+                undecided = true;
+            else if (held.size === 1)
                 markets.add([...held][0]);
         }
-        if (markets.size === 1)
+        if (!undecided && markets.size === 1)
             etf.market = [...markets][0];
+        for (const row of own) {
+            const matched = tentative.get(row);
+            if (!matched)
+                continue;
+            const pool = matched.filter((c) => !etf.used.has(c.code) && market(c.code) === etf.market);
+            place(row, pool.length ? narrow(pool, etf) : null, etf);
+        }
         for (const row of own)
             if (!codes.has(row))
-                place(row, byName(candidates.get(row.componentName) ?? [], etf), etf);
+                place(row, byName(candidatesOf(row), etf), etf);
     }
     const unresolved = [];
     const filled = rows.map((row) => {
@@ -272,14 +349,14 @@ export function clientLookup(client) {
             return Array.isArray(data?.list) ? data.list : [];
         },
         async closes(codes, startDate, endDate) {
-            const data = normalizeRows(await client.call("quote.day-kline", { securityList: codes, startDate, endDate, fieldList: ["securityCode", "tradeDate", "close"], limit: 10_000 }));
+            const data = normalizeRows(await client.call("quote.day-kline", { securityList: codes, startDate, endDate, fieldList: ["securityCode", "tradeDate", "close", "preClose"], limit: 10_000 }));
             const list = Array.isArray(data) ? data : (data?.list ?? []);
             const out = new Map();
             for (const k of list) {
                 if (typeof k.securityCode !== "string" || typeof k.tradeDate !== "string" || typeof k.close !== "number")
                     continue;
                 const series = out.get(k.securityCode) ?? [];
-                series.push([k.tradeDate, k.close]);
+                series.push(typeof k.preClose === "number" && k.preClose > 0 ? [k.tradeDate, k.close, (k.close / k.preClose - 1) * 100] : [k.tradeDate, k.close]);
                 out.set(k.securityCode, series);
             }
             for (const series of out.values())

package/dist/src/core/normalize.js

@@ -46,7 +46,7 @@ export function flagFailedItems(data, label) {
         if (!item || typeof item !== "object")
             return String(item);
         const entry = item;
-        const id = entry.securityCode ?? entry.poolId ?? entry.fileId ?? JSON.stringify(entry);
+        const id = entry.securityCode ?? entry.poolId ?? entry.fileId ?? entry.stockNoteId ?? JSON.stringify(entry);
         return entry.failReason ? `${String(id)}（${String(entry.failReason)}）` : String(id);
     }).join("、");
     process.stderr.write(`[gangtise] warning: ${label} — ${rec.failList.length} item(s) failed while the request itself succeeded: ${detail}. Result marked partial (exit 3).\n`);