gangtise-openapi-cli 0.47.0 → 0.49.0

package/dist/src/core/etfComponents.js

@@ -0,0 +1,301 @@
+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);
+        exact.push(...bySuffix);
+    }
+    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 narrow(matched, etf);
+    }
+    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();
+    await runWithConcurrency(names, PAGE_CONCURRENCY, async (name) => {
+        candidates.set(name, await candidatesFor(name, lookup).catch(() => []));
+    });
+    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 codes = new Map();
+    const etfs = new Map();
+    const place = (row, code, etf) => {
+        codes.set(row, code);
+        if (code)
+            etf.used.add(code);
+    };
+    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 open = (own) => own.filter((r) => !codes.has(r) && typeof r.close === "number" && (candidates.get(r.componentName) ?? []).some(isQuotable));
+    const lagging = [...etfs.values()].filter(({ own }) => open(own).length);
+    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 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 { 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);
+            }
+        }
+    }
+    for (const { own, etf } of etfs.values()) {
+        const markets = new Set([...etf.used].map(market));
+        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)
+                markets.add([...held][0]);
+        }
+        if (markets.size === 1)
+            etf.market = [...markets][0];
+        for (const row of own)
+            if (!codes.has(row))
+                place(row, byName(candidates.get(row.componentName) ?? [], 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/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;
+}

package/dist/src/core/updateCheck.js

@@ -1,36 +1,47 @@
+import { spawn } from "node:child_process";
 import { mkdirSync, readFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { isVersionNewer } from "./args.js";
 import { writeFileAtomicSync } from "./output.js";
 export const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+export const REFRESH_RETRY_MS = 60 * 60 * 1000;
 export const DEFAULT_UPDATE_CHECK_PATH = path.join(os.homedir(), ".config", "gangtise", "update-check.json");
-function saveLatest(cachePath, latest, now) {
+export const REGISTRY = "https://registry.npmjs.org";
+export const PACKAGE_NAME = "gangtise-openapi-cli";
+function readFile(cachePath) {
+    try {
+        const kept = JSON.parse(readFileSync(cachePath, "utf8"));
+        if (kept && typeof kept === "object")
+            return kept;
+    }
+    catch { }
+    return {};
+}
+const answerIn = (kept) => typeof kept.checkedAt === "number" && typeof kept.latest === "string" ? kept : undefined;
+const isFresh = (kept, now) => now - kept.checkedAt >= 0 && now - kept.checkedAt < UPDATE_CHECK_TTL_MS;
+function keep(cachePath, kept) {
     try {
         mkdirSync(path.dirname(cachePath), { recursive: true });
-        writeFileAtomicSync(cachePath, JSON.stringify({ checkedAt: now, latest }), { suffix: "tmp" });
+        writeFileAtomicSync(cachePath, JSON.stringify(kept), { suffix: "tmp" });
     }
     catch {
     }
 }
-export async function latestVersion(cachePath = DEFAULT_UPDATE_CHECK_PATH, timeoutMs = 2000, now = Date.now()) {
+export async function latestVersion(cachePath = DEFAULT_UPDATE_CHECK_PATH, timeoutMs = 2000, now = Date.now(), fresh = false) {
     const cacheable = path.isAbsolute(cachePath);
-    if (cacheable) {
-        try {
-            const cached = JSON.parse(readFileSync(cachePath, "utf8"));
-            const age = typeof cached.checkedAt === "number" ? now - cached.checkedAt : -1;
-            if (typeof cached.latest === "string" && age >= 0 && age < UPDATE_CHECK_TTL_MS)
-                return cached.latest;
-        }
-        catch { }
+    if (cacheable && !fresh) {
+        const kept = answerIn(readFile(cachePath));
+        if (kept && isFresh(kept, now))
+            return kept.latest;
     }
     try {
-        const response = await fetch("https://registry.npmjs.org/gangtise-openapi-cli/latest", { signal: AbortSignal.timeout(timeoutMs) });
+        const response = await fetch(`${REGISTRY}/${PACKAGE_NAME}/latest`, { signal: AbortSignal.timeout(timeoutMs) });
         const latest = (await response.json()).version;
         if (typeof latest !== "string")
             return undefined;
         if (cacheable)
-            saveLatest(cachePath, latest, now);
+            keep(cachePath, { checkedAt: now, latest });
         return latest;
     }
     catch {
@@ -40,6 +51,31 @@ export async function latestVersion(cachePath = DEFAULT_UPDATE_CHECK_PATH, timeo
 export async function checkForUpdate(current) {
     const latest = await latestVersion();
     if (latest && isVersionNewer(latest, current)) {
-        process.stderr.write(`Update available: ${current} → ${latest}\nRun: npm update -g gangtise-openapi-cli\n`);
+        process.stderr.write(`Update available: ${current} → ${latest}\nRun: gangtise update\n`);
+    }
+}
+function refreshInBackground(cachePath) {
+    try {
+        const script = `import(${JSON.stringify(import.meta.url)}).then((m) => m.latestVersion(${JSON.stringify(cachePath)}, 10000, Date.now(), true))`;
+        const child = spawn(process.execPath, ["-e", script], { detached: true, stdio: "ignore", windowsHide: true });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch { }
+}
+export function noticeUpdate(current, cachePath = DEFAULT_UPDATE_CHECK_PATH, now = Date.now(), refresh = refreshInBackground) {
+    if (!path.isAbsolute(cachePath))
+        return;
+    const file = readFile(cachePath);
+    const kept = answerIn(file);
+    const started = file.refreshStartedAt;
+    if ((!kept || !isFresh(kept, now)) && !(typeof started === "number" && now - started >= 0 && now - started < REFRESH_RETRY_MS)) {
+        file.refreshStartedAt = now;
+        keep(cachePath, file);
+        refresh(cachePath);
     }
+    if (!kept || kept.notifiedAt !== undefined || !isVersionNewer(kept.latest, current))
+        return;
+    process.stderr.write(`Update available: ${current} → ${kept.latest}. Run: gangtise update\n`);
+    keep(cachePath, { ...file, notifiedAt: now });
 }

package/dist/src/version.js

@@ -1,14 +1,14 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-function packageVersion() {
+function findPackage() {
     let dir = path.dirname(fileURLToPath(import.meta.url));
     for (;;) {
         const file = path.join(dir, "package.json");
         if (fs.existsSync(file)) {
             const pkg = JSON.parse(fs.readFileSync(file, "utf8"));
             if (pkg.name === "gangtise-openapi-cli" && pkg.version)
-                return pkg.version;
+                return { root: dir, version: pkg.version };
         }
         const parent = path.dirname(dir);
         if (parent === dir)
@@ -16,4 +16,6 @@ function packageVersion() {
         dir = parent;
     }
 }
-export const CLI_VERSION = packageVersion();
+const found = findPackage();
+export const PACKAGE_ROOT = found.root;
+export const CLI_VERSION = found.version;