gangtise-openapi-cli 0.21.0 → 0.22.0

package/dist/src/core/output.js

@@ -8,6 +8,26 @@ export function parseOutputFormat(value) {
     }
     throw new ConfigError(`Unsupported format: ${format}`);
 }
+/** Cell text for terminal-facing formats (table/markdown): newlines collapsed for
+ * alignment, remaining C0/DEL control chars stripped so server data can't inject
+ * terminal escape sequences (ESC[31m etc.) into the user's terminal. */
+function sanitizeCell(value) {
+    return value.replace(/[\r\n]+/g, " ").replace(/[\u0000-\u001f\u007f]/g, "");
+}
+/** Terminal display width: CJK/fullwidth chars occupy 2 columns — padEnd counts
+ * UTF-16 code units and misaligns every table containing Chinese text. */
+function displayWidth(value) {
+    let width = 0;
+    for (const ch of value) {
+        const cp = ch.codePointAt(0);
+        const wide = (cp >= 0x1100 && cp <= 0x115f) || (cp >= 0x2e80 && cp <= 0xa4cf)
+            || (cp >= 0xac00 && cp <= 0xd7a3) || (cp >= 0xf900 && cp <= 0xfaff)
+            || (cp >= 0xfe30 && cp <= 0xfe4f) || (cp >= 0xff00 && cp <= 0xff60)
+            || (cp >= 0xffe0 && cp <= 0xffe6) || (cp >= 0x20000 && cp <= 0x3fffd);
+        width += wide ? 2 : 1;
+    }
+    return width;
+}
 function formatScalar(value) {
     if (value === null || value === undefined) {
         return "";
@@ -17,21 +37,24 @@ function formatScalar(value) {
     }
     return String(value);
 }
+/** Rows for a list: object rows as-is with stray null/scalar rows dropped (one bad
+ * row must not degrade the whole table to index/value pairs — and the streaming CSV
+ * path already skips them, so both paths agree). A list with NO object rows at all
+ * (e.g. plain string codes) still renders as index/value pairs. */
+function rowsFromList(list) {
+    const objectRows = list.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item)));
+    if (objectRows.length > 0)
+        return objectRows;
+    return list.map((item, index) => ({ index, value: item }));
+}
 function toRows(value) {
     if (Array.isArray(value)) {
-        if (value.every((item) => item && typeof item === "object" && !Array.isArray(item))) {
-            return value;
-        }
-        return value.map((item, index) => ({ index, value: item }));
+        return rowsFromList(value);
     }
     if (value && typeof value === "object") {
         const record = value;
         if (Array.isArray(record.list)) {
-            const list = record.list;
-            if (list.every((item) => item && typeof item === "object" && !Array.isArray(item))) {
-                return list;
-            }
-            return list.map((item, index) => ({ index, value: item }));
+            return rowsFromList(record.list);
         }
         return [record];
     }
@@ -42,15 +65,17 @@ function renderTable(rows) {
         return "(empty)";
     }
     const columns = Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
-    // Format every cell once (formatScalar may JSON.stringify objects), collapsing
-    // newlines so multi-line fields don't break alignment. Reuse the matrix for both
-    // width and rendering — and compute widths with reduce, NOT Math.max(...arr):
+    // Format every cell once (formatScalar may JSON.stringify objects), sanitizing
+    // control chars so multi-line fields don't break alignment. Reuse the matrix for
+    // both width and rendering — and compute widths with reduce, NOT Math.max(...arr):
     // spreading a per-row array overflows the call stack on large results (table is
-    // the default format, e.g. `quote day-kline --security all`).
-    const matrix = rows.map((row) => columns.map((column) => formatScalar(row[column]).replace(/[\r\n]+/g, " ")));
-    const widths = columns.map((column, c) => matrix.reduce((max, cells) => Math.max(max, cells[c].length), column.length));
-    const renderLine = (values) => values.map((value, index) => value.padEnd(widths[index], " ")).join("  ");
-    const header = renderLine(columns);
+    // the default format, e.g. `quote day-kline --security all`). Widths and padding
+    // use displayWidth so CJK cells stay aligned.
+    const headerCells = columns.map(sanitizeCell);
+    const matrix = rows.map((row) => columns.map((column) => sanitizeCell(formatScalar(row[column]))));
+    const widths = columns.map((_, c) => matrix.reduce((max, cells) => Math.max(max, displayWidth(cells[c])), displayWidth(headerCells[c])));
+    const renderLine = (values) => values.map((value, index) => value + " ".repeat(Math.max(0, widths[index] - displayWidth(value)))).join("  ");
+    const header = renderLine(headerCells);
     const divider = renderLine(widths.map((width) => "-".repeat(width)));
     const body = matrix.map((cells) => renderLine(cells));
     return [header, divider, ...body].join("\n");
@@ -60,9 +85,11 @@ function renderMarkdown(rows) {
         return "(empty)";
     }
     const columns = Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
-    const header = `| ${columns.join(" | ")} |`;
+    // Column names come from server data (e.g. EDE indicator display names) — escape
+    // them like cell values or a name containing | / , breaks the whole table.
+    const header = `| ${columns.map((column) => sanitizeCell(column).replaceAll("|", "\\|")).join(" | ")} |`;
     const divider = `| ${columns.map(() => "---").join(" | ")} |`;
-    const body = rows.map((row) => `| ${columns.map((column) => formatScalar(row[column]).replace(/[\r\n]+/g, " ").replaceAll("|", "\\|")).join(" | ")} |`);
+    const body = rows.map((row) => `| ${columns.map((column) => sanitizeCell(formatScalar(row[column])).replaceAll("|", "\\|")).join(" | ")} |`);
     return [header, divider, ...body].join("\n");
 }
 function renderCsv(rows) {
@@ -70,7 +97,7 @@ function renderCsv(rows) {
         return "";
     }
     const columns = Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
-    const header = columns.join(",");
+    const header = columns.map(csvEscape).join(",");
     const body = rows.map((row) => columns.map((column) => csvEscape(formatScalar(row[column]))).join(","));
     return [header, ...body].join("\n");
 }
@@ -105,10 +132,24 @@ export async function streamOutputToFile(value, format, outputPath) {
     // Below this row count the join() approach is cheaper than per-row writes.
     if (list.length < 1000)
         return false;
+    // csv can only stream object rows; an all-scalar list has no columns — fall back
+    // to renderOutput's index/value shaping instead of writing a BOM-only file.
+    let csvRows = [];
+    let csvColumns = [];
+    if (format === "csv") {
+        csvRows = list.filter((row) => Boolean(row && typeof row === "object" && !Array.isArray(row)));
+        if (csvRows.length === 0)
+            return false;
+        csvColumns = Array.from(new Set(csvRows.flatMap((row) => Object.keys(row))));
+    }
     const { dirname } = await import("node:path");
     const { createWriteStream } = await import("node:fs");
     await fs.mkdir(dirname(outputPath), { recursive: true });
     const stream = createWriteStream(outputPath, { encoding: "utf8" });
+    // A stream 'error' with no listener (EACCES on open, ENOSPC mid-write) crashes the
+    // process before any write callback fires. Swallow the event here — the failure
+    // still surfaces through the write/end callbacks below.
+    stream.on("error", () => { });
     try {
         if (format === "jsonl") {
             for (const item of list) {
@@ -116,20 +157,23 @@ export async function streamOutputToFile(value, format, outputPath) {
             }
         }
         else {
-            const objectRows = list.filter((row) => Boolean(row && typeof row === "object" && !Array.isArray(row)));
-            const columns = Array.from(new Set(objectRows.flatMap((row) => Object.keys(row))));
-            await writeLine(stream, columns.join(","));
-            for (const row of objectRows) {
-                const cells = columns.map((column) => csvEscape(formatScalar(row[column])));
+            // BOM so Excel double-click decodes Chinese as UTF-8 instead of ANSI/GBK.
+            await writeLine(stream, "\ufeff" + csvColumns.map(csvEscape).join(","));
+            for (const row of csvRows) {
+                const cells = csvColumns.map((column) => csvEscape(formatScalar(row[column])));
                 await writeLine(stream, cells.join(","));
             }
         }
-    }
-    finally {
         await new Promise((resolve, reject) => {
             stream.end((err) => err ? reject(err) : resolve());
         });
     }
+    catch (error) {
+        // Mirror the download path: never leave a truncated file that looks complete.
+        stream.destroy();
+        await fs.unlink(outputPath).catch(() => { });
+        throw error;
+    }
     return true;
 }
 /** Extract a row array from a value: the array itself, or its `.list` property,
@@ -158,10 +202,16 @@ function csvEscape(value) {
 function writeLine(stream, line) {
     return new Promise((resolve, reject) => {
         const ok = stream.write(line + "\n", (err) => err ? reject(err) : undefined);
-        if (ok)
+        if (ok) {
             resolve();
-        else
-            stream.once("drain", () => resolve());
+            return;
+        }
+        // Waiting only for 'drain' would hang forever if the stream errors instead;
+        // race the two and detach the loser so listeners don't pile up per write.
+        const onDrain = () => { stream.off("error", onError); resolve(); };
+        const onError = (err) => { stream.off("drain", onDrain); reject(err); };
+        stream.once("drain", onDrain);
+        stream.once("error", onError);
     });
 }
 export async function saveOutputIfNeeded(content, outputPath) {

package/dist/src/core/printer.js

@@ -16,6 +16,12 @@ export async function printData(data, format, output, cache) {
             const listLen = Array.isArray(meta.list) ? meta.list.length : 0;
             process.stderr.write(`Total: ${meta.total}, showing: ${listLen}\n`);
         }
+        // Partial results (failed pages/shards) exit with code 3: the table/csv/jsonl
+        // renderers only emit the rows, so without a distinct exit code a script or AI
+        // consumer cannot tell a partial export from a complete one.
+        if (meta.partial === true) {
+            process.exitCode = 3;
+        }
     }
     if (output) {
         if (await streamOutputToFile(normalized, format, output)) {
@@ -23,7 +29,9 @@ export async function printData(data, format, output, cache) {
             return;
         }
         const content = renderOutput(normalized, format);
-        await saveOutputIfNeeded(content, output);
+        // CSV files get a BOM so Excel double-click decodes Chinese as UTF-8 (stdout
+        // stays BOM-free for pipes).
+        await saveOutputIfNeeded(format === "csv" ? `\ufeff${content}` : content, output);
         process.stdout.write(`${output}\n`);
         return;
     }

package/dist/src/core/quoteSharding.js

@@ -1,12 +1,9 @@
-import { runWithConcurrency } from "./transport.js";
+import { isVerbose, PAGE_CONCURRENCY, runWithConcurrency } from "./transport.js";
 const DAY_MS = 86_400_000;
 /** API-side row cap (per docs). Used to lift the default 6000-row cap on
  * `--security all` queries so a 2-day A-share shard (~11K rows) isn't
  * silently truncated. Single-security queries are untouched. */
 const ALL_MARKET_LIMIT = 10_000;
-/** Shard fan-out concurrency. Shares the GANGTISE_PAGE_CONCURRENCY knob with
- * pagination (see transport/client) so one env var tunes all request fan-out. */
-const SHARD_CONCURRENCY = Number(process.env.GANGTISE_PAGE_CONCURRENCY ?? 5) || 5;
 function parseDate(value) {
     // Accept yyyy-MM-dd; reject anything else so we can fall back to a single request.
     if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
@@ -46,12 +43,17 @@ function buildShards(start, end, shardDays) {
  * single-security queries this is a no-op.
  */
 export async function callKlineWithSharding(client, endpointKey, body, config) {
-    if (!isAllMarket(body) || !body.startDate || !body.endDate) {
+    if (!isAllMarket(body)) {
         return client.call(endpointKey, body);
     }
     // `--security all` returns thousands of rows per day; lift the default 6000-row
-    // cap to the API max so single-shard requests aren't silently truncated.
+    // cap to the API max so single-shard requests aren't silently truncated. This
+    // must apply even when a date is missing (no sharding possible then, but the
+    // single request still needs the lifted cap).
     const allMarketBody = { ...body, limit: body.limit ?? ALL_MARKET_LIMIT };
+    if (!body.startDate || !body.endDate) {
+        return client.call(endpointKey, allMarketBody);
+    }
     const start = parseDate(body.startDate);
     const end = parseDate(body.endDate);
     if (!start || !end || end < start) {
@@ -62,7 +64,9 @@ export async function callKlineWithSharding(client, endpointKey, body, config) {
         return client.call(endpointKey, allMarketBody);
     }
     const shards = buildShards(start, end, config.shardDays);
-    if (process.env.GANGTISE_VERBOSE === "1" || process.env.GANGTISE_VERBOSE === "true") {
+    // isVerbose() (not a direct env read) so the global --verbose flag reaches
+    // shard logging too — cli.ts enables it via setVerbose in a preAction hook.
+    if (isVerbose()) {
         process.stderr.write(`[gangtise] sharding ${endpointKey} into ${shards.length} requests (${config.shardDays} day(s) each)\n`);
     }
     // Per-shard fault tolerance: a failing shard is recorded and skipped (returns a
@@ -71,7 +75,7 @@ export async function callKlineWithSharding(client, endpointKey, body, config) {
     // every shard on the first rejection.
     const failedShards = [];
     let firstError = null;
-    const results = await runWithConcurrency(shards, config.concurrency ?? SHARD_CONCURRENCY, async (shard) => {
+    const results = await runWithConcurrency(shards, config.concurrency ?? PAGE_CONCURRENCY, async (shard) => {
         try {
             return await client.call(endpointKey, { ...allMarketBody, startDate: shard.startDate, endDate: shard.endDate });
         }

package/dist/src/core/titleCache.js

@@ -75,9 +75,11 @@ function capTitles(merged, freshKeys, cap) {
         }
     }
     if (n < cap) {
-        for (const k of Object.keys(merged)) {
-            if (n >= cap)
-                break;
+        // Newest-inserted keys sit at the END of the merged object — fill in reverse so
+        // eviction drops the oldest entries, not the batch the user just listed yesterday.
+        const rest = Object.keys(merged);
+        for (let i = rest.length - 1; i >= 0 && n < cap; i--) {
+            const k = rest[i];
             if (k in out)
                 continue;
             out[k] = merged[k];

package/dist/src/core/transport.js

@@ -29,6 +29,8 @@ export async function runWithConcurrency(items, concurrency, fn) {
     await Promise.all(Array.from({ length: limit }, () => worker()));
     return results;
 }
+/** Fan-out width for pagination and kline shards — one env knob tunes both. */
+export const PAGE_CONCURRENCY = Number(process.env.GANGTISE_PAGE_CONCURRENCY ?? 5) || 5;
 const RETRYABLE_HTTP_STATUS = new Set([429, 500, 502, 503, 504]);
 const RETRYABLE_NETWORK_CODES = new Set(["ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "EAI_AGAIN", "UND_ERR_SOCKET", "UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT"]);
 const RETRYABLE_API_CODES = new Set(["999999"]);

package/dist/src/version.js

@@ -1,2 +1,2 @@
 // Auto-generated — DO NOT EDIT
-export const CLI_VERSION = "0.21.0";
+export const CLI_VERSION = "0.22.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gangtise-openapi-cli",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "CLI for Gangtise OpenAPI",
   "license": "MIT",
   "repository": {
@@ -37,7 +37,7 @@
     "undici": "^7.16.0"
   },
   "devDependencies": {
-    "@types/node": "^24.3.0",
+    "@types/node": "^20.19.43",
     "tsx": "^4.20.5",
     "typescript": "^5.9.2",
     "vitest": "^3.2.6"