gangtise-openapi-cli 0.48.0 → 0.50.0

package/dist/src/core/endpoints.js

@@ -114,7 +114,7 @@ const ENDPOINT_DEFS = {
         description: "List roadshows",
         billing: { per: "row", price: 10 },
         pagination: { enabled: true, maxPageSize: 50 },
-        rowId: "id",
+        rowId: "roadshowId",
         rowIdUnverified: true,
     },
     "insight.site-visit.list": {
@@ -124,7 +124,7 @@ const ENDPOINT_DEFS = {
         description: "List site visits",
         billing: { per: "row", price: 10 },
         pagination: { enabled: true, maxPageSize: 50 },
-        rowId: "id",
+        rowId: "siteVisitId",
         rowIdUnverified: true,
     },
     "insight.strategy.list": {
@@ -134,7 +134,7 @@ const ENDPOINT_DEFS = {
         description: "List strategy meetings",
         billing: { per: "row", price: 10 },
         pagination: { enabled: true, maxPageSize: 50 },
-        rowId: "id",
+        rowId: "strategyMeetingId",
         rowIdUnverified: true,
     },
     "insight.forum.list": {
@@ -144,7 +144,7 @@ const ENDPOINT_DEFS = {
         description: "List forums",
         billing: { per: "row", price: 10 },
         pagination: { enabled: true, maxPageSize: 50 },
-        rowId: "id",
+        rowId: "forumId",
         rowIdUnverified: true,
     },
     "insight.performance-calendar.list": {
@@ -439,6 +439,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",
@@ -1151,6 +1158,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,13 +48,13 @@ 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 取值是否合法。",
+    "130002": "确认 ID 有效且本账号可见（云盘的文件 / 文件夹 ID 用 `vault drive-folder-list` 核对，笔记 ID 用 `vault stock-note-list` 核对；删除类命令收到此码可能是目标已被删掉）；下载类还需检查 --file-type 取值是否合法。",
     "130003": "资源未生成或该条记录未附带文件——换一条有附件的记录（列表里 hasAttachment/hasFile 为 true 的），或稍后再试。",
     "130004": "下载 ID 需为数字，检查该命令的 --*-id 参数是否传对。",
     "130005": "对照命令 --help 检查 --file-type / --content-type 取值。",
@@ -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

@@ -0,0 +1,358 @@
+import { beijingDateString } from "./args.js";
+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 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;
+const CLOSES_BATCH = 1000;
+const squash = (name) => name.replace(/\s+/g, "");
+const base = (name) => squash(name).replace(/-[A-Z]+$/, "");
+const ticker = (code) => code.slice(0, code.lastIndexOf("."));
+const exchange = (code) => code.slice(code.lastIndexOf(".") + 1);
+const market = (code) => {
+    const suffix = exchange(code);
+    return ["SH", "SZ", "BJ"].includes(suffix) ? "CN" : ["O", "N", "A"].includes(suffix) ? "US" : suffix;
+};
+function toCandidates(rows) {
+    return rows.flatMap((row) => {
+        const r = row;
+        return typeof r.gtsCode === "string" && typeof r.gtsName === "string" && r.category !== "index"
+            ? [{ code: r.gtsCode, name: r.gtsName, category: String(r.category), prefix: false }]
+            : [];
+    });
+}
+async function candidatesFor(name, lookup) {
+    const key = squash(name);
+    const found = toCandidates(await lookup.search(key));
+    const exact = found.filter((c) => base(c.name) === base(key) || ticker(c.code) === key);
+    if (/^[A-Z][A-Z0-9]{0,6}$/.test(key) && !exact.some((c) => market(c.code) === "US")) {
+        const bySuffix = (await Promise.all(["O", "N"].map((suffix) => lookup.search(`${key}.${suffix}`))))
+            .flatMap((rows) => toCandidates(rows))
+            .filter((c) => ticker(c.code) === key);
+        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 }))];
+}
+function narrow(candidates, etf) {
+    let left = candidates;
+    if (new Set(left.map((c) => market(c.code))).size > 1) {
+        if (!etf.market)
+            return null;
+        left = left.filter((c) => market(c.code) === etf.market);
+    }
+    if (left.length > 1) {
+        const same = left.filter((c) => exchange(c.code) === etf.exchange);
+        if (same.length)
+            left = same;
+    }
+    return left.length === 1 ? left[0].code : null;
+}
+function byPrice(row, candidates, prices, etf, unchecked) {
+    const close = typeof row.close === "number" ? row.close : undefined;
+    if (close === undefined)
+        return undefined;
+    const open = candidates.filter((c) => !etf.used.has(c.code));
+    for (const tier of [open.filter((c) => !c.prefix), open.filter((c) => c.prefix)]) {
+        if (tier.some((c) => !prices.get(c.code)?.some((p) => p > 0) && unchecked(c)))
+            return undefined;
+        const matched = tier.filter((c) => prices.get(c.code)?.some((p) => agrees(close, p)));
+        if (matched.length)
+            return matched;
+    }
+    return undefined;
+}
+function byName(candidates, etf) {
+    if (!etf.market)
+        return null;
+    const pool = candidates.filter((c) => !c.prefix && !etf.used.has(c.code) && market(c.code) === etf.market);
+    return pool.length ? narrow(pool, etf) : null;
+}
+async function splitting(codes, fetch) {
+    try {
+        return await fetch(codes);
+    }
+    catch (error) {
+        if (codes.length === 1 || error?.code !== "120001")
+            return new Map();
+        const half = Math.ceil(codes.length / 2);
+        const first = await splitting(codes.slice(0, half), fetch);
+        return new Map([...first, ...await splitting(codes.slice(half), fetch)]);
+    }
+}
+const inBatches = (codes, size) => Array.from({ length: Math.ceil(codes.length / size) }, (_, i) => codes.slice(i * size, (i + 1) * size));
+function listDates(rows, candidates, history) {
+    const votes = new Map();
+    for (const row of rows) {
+        if (typeof row.close !== "number")
+            continue;
+        const exact = (candidates.get(row.componentName) ?? []).filter((c) => !c.prefix);
+        if (exact.length !== 1)
+            continue;
+        const tally = votes.get(market(exact[0].code)) ?? new Map();
+        for (const [date, close] of history.get(exact[0].code) ?? []) {
+            if (agrees(row.close, close))
+                tally.set(date, (tally.get(date) ?? 0) + 1);
+        }
+        votes.set(market(exact[0].code), tally);
+    }
+    const dates = new Map();
+    for (const [where, tally] of votes) {
+        const ranked = [...tally].sort((a, b) => b[1] - a[1]);
+        if (ranked.length && ranked[0][1] >= 2 && ranked[1]?.[1] !== ranked[0][1])
+            dates.set(where, ranked[0][0]);
+    }
+    return dates;
+}
+function closesOn(dates, history) {
+    const out = new Map();
+    for (const [code, series] of history) {
+        const date = dates.get(market(code));
+        if (!date)
+            continue;
+        const last = series.filter(([d]) => d <= date).at(-1);
+        if (last)
+            out.set(code, [last[1]]);
+    }
+    return out;
+}
+const carriesCode = (row) => typeof row.componentCode === "string" && row.componentCode !== "";
+const needsCode = (row) => !carriesCode(row) && typeof row.componentName === "string";
+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) => {
+        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 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" && 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) => 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));
+        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) && 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()) {
+        const markets = new Set([...etf.used].map(market));
+        let undecided = own.some((r) => failed.has(r.componentName));
+        for (const r of own) {
+            if (codes.get(r) || tentative.has(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 (!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(candidatesOf(row), etf), etf);
+    }
+    const unresolved = [];
+    const filled = rows.map((row) => {
+        if (!codes.has(row))
+            return row;
+        const code = codes.get(row) ?? null;
+        if (!code)
+            unresolved.push({ fundCode: row.fundCode, serialNumber: row.serialNumber, componentName: row.componentName });
+        const out = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (key === "componentCode")
+                continue;
+            out[key] = value;
+            if (key === "serialNumber")
+                out.componentCode = code;
+        }
+        if (!("componentCode" in out))
+            out.componentCode = code;
+        return out;
+    });
+    return { rows: filled, unresolved };
+}
+export async function addComponentCodes(data, lookup) {
+    const list = data?.list;
+    if (!Array.isArray(list))
+        return data;
+    const rows = list;
+    const pending = rows.filter(needsCode).length;
+    if (!pending)
+        return data;
+    const filled = await fillComponentCodes(rows, lookup);
+    const left = filled.unresolved.map((u) => `${String(u.fundCode)} ${String(u.componentName)}`);
+    const shown = left.length > 20 ? `${left.slice(0, 20).join(", ")}, …` : left.join(", ");
+    process.stderr.write(`[gangtise] note: the API returns component names only; componentCode is the CLI's match for each name (looked up in the securities list, and checked against the component's close where it can be quoted): ${pending - left.length} of ${pending} rows.${left.length ? ` Left null (cash lines, commodities, names without a confident match): ${shown}` : ""}\n`);
+    return { ...data, list: filled.rows };
+}
+const MARKET_SECTORS = ["1000000002", "1000002615", "1000002618"];
+export async function loadSecurityTable(fetchSector) {
+    try {
+        const markets = await Promise.all(MARKET_SECTORS.map(async (sectorId) => {
+            const data = await fetchSector(sectorId);
+            const list = (Array.isArray(data?.list) ? data.list : []).flatMap((row) => {
+                const r = row;
+                return typeof r.gtsCode === "string" && typeof r.gtsName === "string" ? [[r.gtsCode, r.gtsName]] : [];
+            });
+            if (!list.length)
+                throw new Error(`sector ${sectorId} listed nothing`);
+            return list;
+        }));
+        return markets.flat();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function tableSearch(list) {
+    const byBase = new Map();
+    const byTicker = new Map();
+    const byCode = new Map();
+    const add = (index, key, listing) => {
+        const listed = index.get(key);
+        if (listed)
+            listed.push(listing);
+        else
+            index.set(key, [listing]);
+    };
+    for (const listing of list) {
+        add(byBase, base(listing[1]), listing);
+        add(byTicker, ticker(listing[0]), listing);
+        byCode.set(listing[0], listing);
+    }
+    const bases = [...byBase.keys()];
+    return (keyword) => {
+        const key = squash(keyword);
+        const name = base(key);
+        const coded = byCode.get(key);
+        const exact = [...(byBase.get(name) ?? []), ...(byTicker.get(key) ?? []), ...(coded ? [coded] : [])];
+        if (!exact.length)
+            return undefined;
+        const prefix = name.length >= 2 ? bases.filter((b) => b !== name && b.startsWith(name)).flatMap((b) => byBase.get(b)) : [];
+        return [...new Set([...exact, ...prefix])].map(([gtsCode, gtsName]) => ({ gtsCode, gtsName, category: "stock" }));
+    };
+}
+export function clientLookup(client) {
+    let table;
+    const local = () => (table ??= loadSecurityTable((sectorId) => client.call("reference.sector-constituents", { sectorId })).then((list) => list && tableSearch(list)));
+    return {
+        async search(keyword) {
+            const hits = (await local())?.(keyword);
+            if (hits)
+                return hits;
+            const data = await client.call("reference.securities-search", { keyword, top: 10 });
+            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 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]);
+                out.set(k.securityCode, series);
+            }
+            for (const series of out.values())
+                series.sort((a, b) => (a[0] < b[0] ? -1 : 1));
+            return out;
+        },
+        async quotes(codes) {
+            const data = normalizeRows(await client.call("quote.realtime", { securityList: codes }));
+            const list = Array.isArray(data) ? data : (data?.list ?? []);
+            const out = new Map();
+            for (const q of list) {
+                const prices = [q.preClose, q.latestPrice].filter((p) => typeof p === "number");
+                if (typeof q.securityCode === "string" && prices.length)
+                    out.set(q.securityCode, prices);
+            }
+            return out;
+        },
+    };
+}

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`);

package/dist/src/core/selfUpdate.js

@@ -0,0 +1,94 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { isVersionNewer } from "./args.js";
+import { PACKAGE_NAME, REGISTRY } from "./updateCheck.js";
+export const SKILL_HOMES = [[".claude", "skills"], [".codex", "skills"], [".openclaw", "workspace", "skills"], [".hermes", "skills"]];
+const SKILL_DIR = "gangtise-openapi";
+const runNpm = (args, inherit) => {
+    const options = { encoding: "utf8", stdio: inherit ? "inherit" : "pipe" };
+    const result = process.platform === "win32" ? spawnSync(["npm", ...args].join(" "), { ...options, shell: true }) : spawnSync("npm", args, options);
+    return { status: result.status, stdout: result.stdout ?? "" };
+};
+function isSymlink(file) {
+    try {
+        return fs.lstatSync(file).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+function samePath(a, b) {
+    try {
+        return fs.realpathSync(a) === fs.realpathSync(b);
+    }
+    catch {
+        return false;
+    }
+}
+export function installVersion(version, packageRoot, npm = runNpm) {
+    if (!/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(version))
+        throw new Error(`The registry answered an unexpected version (${JSON.stringify(version)}); nothing was installed.`);
+    const root = npm(["root", "-g"], false);
+    const globalRoot = root.status === 0 ? root.stdout.trim() : "";
+    if (!globalRoot)
+        throw new Error("Could not run npm, which gangtise update uses to install. Install Node.js with npm, or update gangtise the way it was installed.");
+    const installed = path.join(globalRoot, PACKAGE_NAME);
+    if (!samePath(installed, packageRoot)) {
+        throw new Error(`This gangtise runs from ${packageRoot}, which is not npm's global install (${globalRoot}). Update it the way it was installed — in a clone: git pull && npm install && npm run build.`);
+    }
+    if (isSymlink(installed)) {
+        throw new Error(`This gangtise is a checkout linked into npm's global install (${installed} → ${packageRoot}, npm link). Update the checkout instead: git pull && npm install && npm run build.`);
+    }
+    const spec = `${PACKAGE_NAME}@${version}`;
+    const install = npm(["install", "-g", spec, `--registry=${REGISTRY}`], true);
+    if (install.status !== 0) {
+        throw new Error(`npm install exited with ${install.status ?? "a signal"}. On a permission error (EACCES), run: sudo npm install -g ${spec} --registry=${REGISTRY} — then gangtise update again to refresh the Agent Skill copies.`);
+    }
+    const landed = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8")).version;
+    if (landed !== version)
+        throw new Error(`npm reported success, but ${packageRoot} still holds ${landed}.`);
+}
+function skillVersion(dir) {
+    try {
+        return /^version:\s*["']?([^"'\n]+)/m.exec(fs.readFileSync(path.join(dir, "SKILL.md"), "utf8"))?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function refreshSkillCopies(packageRoot, home) {
+    const source = path.join(packageRoot, SKILL_DIR);
+    const version = skillVersion(source);
+    if (!version)
+        return [];
+    const replaced = [];
+    for (const parts of SKILL_HOMES) {
+        const target = path.join(home, ...parts, SKILL_DIR);
+        let stat;
+        try {
+            stat = fs.lstatSync(target);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isDirectory())
+            continue;
+        const current = skillVersion(target);
+        if (current !== undefined && !isVersionNewer(version, current))
+            continue;
+        const staging = `${target}.update-${process.pid}`;
+        fs.rmSync(staging, { recursive: true, force: true });
+        try {
+            fs.cpSync(source, staging, { recursive: true });
+            fs.rmSync(target, { recursive: true, force: true });
+            fs.renameSync(staging, target);
+        }
+        catch (error) {
+            fs.rmSync(staging, { recursive: true, force: true });
+            throw new Error(`Could not replace the Agent Skill copy at ${target} (${error.message}). Copy ${source} there again.`);
+        }
+        replaced.push(`Agent Skill updated: ${target} (${current ?? "no version"} → ${version})`);
+    }
+    return replaced;
+}