candidate-pool 2.0.0

package/db/migrate.js

@@ -0,0 +1,177 @@
+'use strict';
+/*
+ * db/migrate.js —— 数据库结构同步（本地 db/local.db ←→ 线上 Cloudflare D1）
+ * ---------------------------------------------------------------------------
+ * 为什么需要它（2026-09-21 事故）：改了 schema.sql 之后，**没有任何可靠路径**能把它
+ * 落到两个库上 —— 本地 sqlite 只在「缺 run_batch 表」时才建表，远程完全靠人工
+ * `wrangler d1 execute`。于是新增的 tail_run / tail_pick 线上从未被创建，
+ * /api/tail/* 全部 `no such table` → 四个页面 HTTP 500。详见 db/ddl.js 头部。
+ *
+ * 一条命令同步两边：
+ *   npm run db:migrate          # 同步线上 D1（默认；无凭据则提示并跳过）
+ *   npm run db:migrate:local    # 同步本地 db/local.db
+ *   npm run db:migrate:both     # 两边一起
+ *   npm run db:migrate:dry      # 只打印差异，不写库（安全预览）
+ *
+ * 执行策略：**差异驱动**，不是「整份重放」。
+ *   schema.sql 是期望结构，先用 db/diff.js 与库中实际结构比对，只补真正缺的东西：
+ *     缺表 → CREATE TABLE ；缺列 → ALTER TABLE ADD COLUMN ；缺索引 → CREATE INDEX
+ *   （整份重放对已存在的表是空操作，新增字段永远不会生效 —— 所以必须做差异识别。）
+ *
+ * 需要人工写迁移的情况（本脚本只识别、不擅自执行，避免静默丢数据）：
+ *   · 改列定义（类型/约束）→ SQLite 不支持直接改，需重建表
+ *   · 删列 / 删表           → 涉及数据丢弃
+ *   · 不满足 ALTER 限制的新列（主键 / UNIQUE / NOT NULL 无默认值）
+ *   这些写成 db/migrations/NNN-描述.sql，由本脚本按文件名顺序执行且只执行一次。
+ */
+
+const crypto = require('crypto');
+const { resolveTargets } = require('./clients');
+const ddl = require('./ddl');
+const diffLib = require('./diff');
+const { dayjs } = require('../time');
+
+const argv = process.argv;
+const DRY = argv.includes('--dry-run') || argv.includes('--dry');
+
+const META_TABLE = 'schema_meta';
+// 与 schema.sql 中的定义保持一致（此处再写一遍是为了「先有表才能读 hash」的启动顺序）
+const META_DDL = `CREATE TABLE IF NOT EXISTS ${META_TABLE} (
+  key        TEXT PRIMARY KEY,
+  value      TEXT,
+  updated_at TEXT)`;
+const UPSERT_META = `INSERT INTO ${META_TABLE} (key, value, updated_at) VALUES (?,?,?)
+  ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`;
+
+const hash12 = (s) => crypto.createHash('sha1').update(s).digest('hex').slice(0, 12);
+const nowBjt = () => dayjs.tz().format('YYYY-MM-DD HH:mm:ss');
+const log = (m) => console.log(m);
+const warn = (m) => console.warn(m);
+
+/** 读出库中的实际结构（表 + 索引的 DDL 原文，SQLite 会把 CREATE 语句存在 sqlite_master 里）。 */
+async function readActual(client) {
+  const tables = await client.query(
+    "SELECT name, sql FROM sqlite_master WHERE type = 'table' AND sql IS NOT NULL",
+  );
+  const indexes = await client.query(
+    "SELECT name, sql FROM sqlite_master WHERE type = 'index' AND sql IS NOT NULL",
+  );
+  const text = [...tables, ...indexes].map((r) => `${r.sql};`).join('\n');
+  return diffLib.parseObjects(text);
+}
+
+/** 应用差异：只执行安全项，返回实际执行的语句条数。 */
+async function applyDiff(client, d) {
+  const stmts = diffLib.applyStatements(d).map((sql) => ({ sql }));
+  if (stmts.length) await client.batch(stmts);
+  return stmts.length;
+}
+
+function reportDiff(tag, d) {
+  const bits = [];
+  if (d.addTables.length) bits.push(`新建表 ${d.addTables.map((t) => t.table).join(', ')}`);
+  if (d.addColumns.length) bits.push(`新增列 ${d.addColumns.map((c) => `${c.table}.${c.column}`).join(', ')}`);
+  if (d.addIndexes.length) bits.push(`新建索引 ${d.addIndexes.map((i) => i.name).join(', ')}`);
+  log(`[${tag}] ${bits.length ? bits.join('；') : '结构已是最新，无需变更'}`);
+}
+
+function reportManual(tag, d) {
+  for (const c of d.unsafeColumns) {
+    warn(`[${tag}] ⚠ 无法自动加列 ${c.table}.${c.column}（${c.reason}）→ 请写 db/migrations/ 迁移`);
+  }
+  for (const c of d.changedColumns) {
+    warn(`[${tag}] ⚠ 列定义已变 ${c.table}.${c.column}：库里「${c.actual}」≠ 期望「${c.desired}」→ 需手写迁移（SQLite 不支持直接改列）`);
+  }
+  for (const c of d.droppedColumns) {
+    warn(`[${tag}] ⚠ schema.sql 里已没有列 ${c.table}.${c.column}，但库里仍存在：本脚本不会自动删列`);
+  }
+  for (const t of d.droppedTables) {
+    warn(`[${tag}] ⚠ schema.sql 里已没有表 ${t}，但库里仍存在：本脚本不会自动删表`);
+  }
+}
+
+async function syncOne(target, statements, migrations) {
+  const { name, client } = target;
+
+  const desired = diffLib.parseObjects(ddl.readSchema());
+  const actual = await readActual(client);
+  const d = diffLib.diffSchema(desired, actual);
+
+  let oldHash = null;
+  try {
+    const rows = await client.query(`SELECT value FROM ${META_TABLE} WHERE key = ?`, ['schema_hash']);
+    oldHash = rows && rows.length ? rows[0].value : null;
+  } catch (_) {
+    oldHash = null; // schema_meta 尚不存在（首次运行）
+  }
+  const newHash = hash12(ddl.readSchema());
+
+  reportDiff(name, d);
+  reportManual(name, d);
+
+  if (DRY) {
+    const n = d.addTables.length + d.addColumns.length + d.addIndexes.length;
+    log(`[${name}] --dry-run：以上 ${n} 项结构变更未执行；schema hash ${newHash}`);
+    return;
+  }
+
+  // 写入前先确保元信息表存在（否则无法记录 hash 与已应用迁移）
+  await client.batch([{ sql: META_DDL }]);
+
+  let applied = await applyDiff(client, d);
+
+  // 解析器安全网：万一 schema.sql 的写法超出解析能力（解析出 0 张表），退回整份重放。
+  // IF NOT EXISTS 保证重放无副作用，只是「新建整表」生效 —— 聊胜于无，不会更糟。
+  if (desired.tables.size === 0) {
+    warn(`[${name}] ⚠ 未能从 schema.sql 解析出任何表，退化为整份重放（请检查 db/diff.js 的解析规则）`);
+    await client.batch(statements.map((sql) => ({ sql })));
+    applied += statements.length;
+  }
+
+  // 增量迁移：按文件名顺序，只执行尚未记录过的
+  const doneRows = await client.query(`SELECT key FROM ${META_TABLE} WHERE key LIKE 'mig:%'`);
+  const done = new Set((doneRows || []).map((r) => r.key));
+  const migrated = [];
+  for (const m of migrations) {
+    const key = `mig:${m.name}`;
+    if (done.has(key)) continue;
+    await client.batch(m.statements.map((sql) => ({ sql })));
+    await client.batch([{ sql: UPSERT_META, params: [key, hash12(m.statements.join(';')), nowBjt()] }]);
+    migrated.push(m.name);
+  }
+  if (migrated.length) log(`[${name}] 已应用迁移 ${migrated.join(', ')}`);
+
+  await client.batch([{ sql: UPSERT_META, params: ['schema_hash', newHash, nowBjt()] }]);
+  log(
+    `[${name}] 完成，执行 ${applied} 条 DDL` +
+      (oldHash && oldHash !== newHash ? `；schema hash ${oldHash} → ${newHash}` : `；schema hash ${newHash}`),
+  );
+}
+
+(async () => {
+  const { targets, notes } = resolveTargets(argv);
+  for (const n of notes) log(`[提示] ${n}`);
+
+  const statements = ddl.loadStatements();
+  const migrations = ddl.loadMigrations();
+  log(`[schema] ${ddl.SCHEMA_FILE} → ${statements.length} 条语句；增量迁移文件 ${migrations.length} 个`);
+
+  if (!targets.length) {
+    log('[结束] 没有可同步的目标库（配好凭据后重跑，或加 --local 同步本地）');
+    return;
+  }
+
+  let failed = false;
+  for (const t of targets) {
+    try {
+      await syncOne(t, statements, migrations);
+    } catch (e) {
+      failed = true;
+      console.error(`[${t.name}] 失败：${(e && e.message) || e}`);
+    }
+  }
+  if (failed) process.exit(1);
+})().catch((e) => {
+  console.error('[致命]', (e && e.stack) || e);
+  process.exit(1);
+});

package/db/normalize.js

@@ -0,0 +1,129 @@
+'use strict';
+// 将一份初筛快照（data/snapshot-<锚定日>.json）规范化为入库结构。
+// 关键：tier 由 r01/r07/r05 字段重新推导（快照里不含 tier，保证与流水线口径一致），
+//      同票跨 run 自然成多行，满足「不同时期收录、全保留可区分」。
+// 时间统一走 dayjs（北京时间 YYYY-MM-DD HH:mm:ss），见 ../time。
+//
+// 三个输出的**收录范围不同**，别混为一谈：
+//   picks  → 只收「被分类的票」（重点/次级/条件 + R07/R05 触发），是入选记录；
+//   prices → **全观察池 × 本锚定日**，是 N 日复盘要的日线序列（与是否入选无关）；
+//   base   → 只收被分类的票的档案（候选列表/详情页用）。
+// 三者原来共用一个 `continue`，导致日线只写了入选日 → N 日收益口径长期失真。
+
+const { now: fmtNow } = require('../time');
+
+function tierOf(s) {
+  const r = s.r01 || {};
+  if (r.ok) return 'high';                                   // 重点关注：R01 四门槛全过
+  if (r.capOk && r.highZoneOk && (r.core ?? 0) >= 2) {
+    return (r.core >= 3) ? 'secondary' : 'conditional';      // 次级 / 条件
+  }
+  return 'excluded';
+}
+
+// 「是否入选」：只入库被分类的票（重点/次级/条件），或触发 R07 补涨 / R05 尾盘异动的票。
+// 与用户要求一致——只保存分类(R01/R07/R05/重点、次级、条件)的票，不保存 377 只全部。
+// 注意：R07/R05 是叠加在个股上的信号，可能单独触发（未达 R01 梯队），这类票 tier 记为 excluded
+//       但 r07_laggard / r05_partial 标记为 1，前端据此仍能识别其入选维度。
+function isPicked(s) {
+  const r = s.r01 || {};
+  if (r.ok) return true;                                              // 重点：R01 全过
+  if (r.capOk && r.highZoneOk && (r.core ?? 0) >= 2) return true;     // 次级 / 条件
+  if (s.r07 && s.r07.laggard) return true;                            // R07 板块内补涨
+  if (s.r05 && s.r05.verdict === 'partial') return true;              // R05 尾盘异动部分触发
+  return false;
+}
+
+function reasonOf(s) {
+  const r = s.r01 || {};
+  const parts = [];
+  if (r.ok) parts.push('R01 量能验证突破（四门槛全过）');
+  if (s.r07 && s.r07.laggard) parts.push('R07 板块内补涨滞后');
+  if (s.r05 && s.r05.verdict === 'partial') parts.push('R05 尾盘量价达标（部分触发）');
+  if (!parts.length) {
+    if (r.capOk === false && r.mktCapYi != null) parts.push(`市值 ${Number(r.mktCapYi).toFixed(1)} 亿超出 20–500 亿区间`);
+    else if (r.capOk === false && r.mktCapYi == null) parts.push('市值数据缺失');
+    if (r.highZoneOk === false) parts.push('处于 52 周高位区');
+    if ((r.core ?? 0) < 2) parts.push(`量价突破仅达成 ${r.core ?? 0}/4`);
+    if (r.error) parts.push('行情数据缺失');
+    if (s.r05 && s.r05.verdict === 'gap') parts.push('R05 分时数据缺口');
+  }
+  return parts.join('；') || '未触发';
+}
+
+// 入参 snap：{ anchor, target, stocks:[...], sectors:[...], ... }
+function normalizeSnap(snap) {
+  const { anchor, target, stocks = [] } = snap;
+  const ts = fmtNow();   // 北京时间 YYYY-MM-DD HH:mm:ss
+  const picks = [], prices = [], base = [];
+  let high = 0, secondary = 0, conditional = 0, excluded = 0;
+  let r01 = 0, r07 = 0, r05 = 0, err = 0;
+
+  for (const s of stocks) {
+    const r = s.r01 || {};
+    const tier = tierOf(s);
+    if (tier === 'high') high++;
+    else if (tier === 'secondary') secondary++;
+    else if (tier === 'conditional') conditional++;
+    else excluded++;
+    if (r.ok) r01++;
+    if (s.r07 && s.r07.laggard) r07++;
+    if (s.r05 && s.r05.verdict === 'partial') r05++;
+    if (r.error) err++;
+
+    // —— 行情：**全观察池 × 本锚定日**，与「是否入选」无关 ——
+    // N 日收益 = 「锚定日之后第 N 个交易日」的收盘 vs 入选价，前提是每只票每个交易日都有行。
+    // 原来只写入选日那一行，序列必然断档：下一行往往是「该票**下一次被入选**那天」，
+    // 实测平均隔 8.9 个自然日（最长 37 天）、只有 19% 真的隔 1 天 —— N1 报的其实是第 8~37 天。
+    // 停牌 / 行情缺失（close 为空）**不写行**：写一行 null 会占掉一个交易日的位置，
+    // 让「第 N 个交易日」整体前移，比缺一行更糟。
+    const close = (typeof r.close === 'number' && r.close > 0) ? r.close : null;
+    if (close !== null) {
+      prices.push({
+        code: s.code, date: anchor, open: null, high: null, low: null,
+        close, chg_pct: r.chg ?? null, turnover: r.turn ?? null,
+        circ_market_cap: r.circCapYi != null ? r.circCapYi * 1e8 : null,
+        total_market_cap: r.mktCapYi != null ? r.mktCapYi * 1e8 : null,
+      });
+    }
+
+    // —— 入选记录 / 基础档案：只存被分类的票（重点/次级/条件/R07/R05），不保存全部 377 只 ——
+    // 与上面的行情是两回事：行情要「全池、逐日、相邻」，入选记录只要「被分类的票」。
+    if (!isPicked(s)) continue;
+
+    picks.push({
+      anchor_date: anchor, code: s.code, name: s.name,
+      sector: s.sector || '未分类', tier,
+      r01_ok: r.ok ? 1 : 0,
+      r07_laggard: (s.r07 && s.r07.laggard) ? 1 : 0,
+      r05_partial: (s.r05 && s.r05.verdict === 'partial') ? 1 : 0,
+      core: r.core ?? null, r01_chg: r.chg ?? null, price: r.close ?? null,
+      turnover: r.turn ?? null,
+      vol_ratio: r.volRatio ?? null,
+      circ_market_cap: r.circCapYi != null ? r.circCapYi * 1e8 : null,
+      total_market_cap: r.mktCapYi != null ? r.mktCapYi * 1e8 : null,
+      sector_pct: (s.r07 && s.r07.sectorPct) ?? null,
+      sector_rank: (s.r07 && s.r07.sectorRank) ?? null,
+      reason: reasonOf(s), picked_at: ts,
+    });
+
+    base.push({ code: s.code, name: s.name, sector: s.sector || '未分类', updated_at: ts });
+  }
+
+  const run = {
+    anchor_date: anchor, target_date: target, run_at: ts,
+    universe_count: stocks.length, r01_count: r01, r07_count: r07, r05_count: r05,
+    high_count: high, secondary_count: secondary, conditional_count: conditional,
+    excluded_count: excluded,
+    kline_fail_rate: stocks.length ? err / stocks.length : null,
+    source: 'tencent-live', note: '',
+  };
+
+  const seen = new Set();
+  const baseUniq = base.filter(b => (seen.has(b.code) ? false : (seen.add(b.code), true)));
+  return { run, picks, prices, base: baseUniq };
+}
+
+exports.normalizeSnap = normalizeSnap;
+exports.tierOf = tierOf;
+exports.reasonOf = reasonOf;

package/db/persist.js

@@ -0,0 +1,90 @@
+'use strict';
+// 将规范化后的快照写入 Cloudflare D1（run_batch + pick_record + price_daily + stock_base）
+// 幂等：同一锚定日重复跑不会重复插入（run_batch UNIQUE anchor_date；pick_record UNIQUE(run_id,code)）
+const { normalizeSnap } = require('./normalize');
+
+const RUN_Q = `INSERT OR IGNORE INTO run_batch
+  (anchor_date,target_date,run_at,universe_count,r01_count,r07_count,r05_count,
+   high_count,secondary_count,conditional_count,excluded_count,kline_fail_rate,source,note)
+  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`;
+const RUN_SEL = 'SELECT id FROM run_batch WHERE anchor_date=?';
+
+// 入选 / 行情写入采用「recency guard」而非 INSERT OR REPLACE：
+//   同一锚定日若被本地与 GitHub 两端重复写入，仅当新快照的 run_at（数据生成时刻）≥ 已有值才覆盖，
+//   避免「陈旧离线兜底数据」把「新鲜实时数据」顶掉（双写冲突的核心护栏之一）。
+// 新行（无冲突）正常 INSERT；冲突且更新条件不满足时静默保留较新数据。
+const PICK_Q = `INSERT INTO pick_record
+  (run_id,anchor_date,code,name,sector,tier,r01_ok,r07_laggard,r05_partial,core,r01_chg,price,
+   turnover,vol_ratio,circ_market_cap,total_market_cap,sector_pct,sector_rank,reason,picked_at,run_at)
+  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+  ON CONFLICT(run_id, code) DO UPDATE SET
+    name=excluded.name, sector=excluded.sector, tier=excluded.tier, r01_ok=excluded.r01_ok,
+    r07_laggard=excluded.r07_laggard, r05_partial=excluded.r05_partial, core=excluded.core,
+    r01_chg=excluded.r01_chg, price=excluded.price, turnover=excluded.turnover,
+    vol_ratio=excluded.vol_ratio,
+    circ_market_cap=excluded.circ_market_cap, total_market_cap=excluded.total_market_cap,
+    sector_pct=excluded.sector_pct, sector_rank=excluded.sector_rank, reason=excluded.reason,
+    picked_at=excluded.picked_at, run_at=excluded.run_at
+  WHERE excluded.run_at >= pick_record.run_at OR pick_record.run_at IS NULL`;
+const PRICE_Q = `INSERT INTO price_daily
+  (code,date,open,high,low,close,chg_pct,turnover,circ_market_cap,total_market_cap,run_at)
+  VALUES (?,?,?,?,?,?,?,?,?,?,?)
+  ON CONFLICT(code, date) DO UPDATE SET
+    open=excluded.open, high=excluded.high, low=excluded.low, close=excluded.close,
+    chg_pct=excluded.chg_pct, turnover=excluded.turnover,
+    circ_market_cap=excluded.circ_market_cap, total_market_cap=excluded.total_market_cap,
+    run_at=excluded.run_at
+  WHERE excluded.run_at >= price_daily.run_at OR price_daily.run_at IS NULL`;
+const BASE_Q = `INSERT OR IGNORE INTO stock_base (code,name,sector,updated_at) VALUES (?,?,?,?)`;
+
+// 惰性迁移：为既有 D1 / 本地 SQLite 补上 run_at 列（新库由 schema.sql 直接建好）。
+// 两端都会跑，先到者成功、后到者捕获「列已存在」忽略即可。
+let _migrated = false;
+async function ensureColumns(client) {
+  if (_migrated) return;
+  _migrated = true;
+  for (const sql of [
+    'ALTER TABLE pick_record ADD COLUMN run_at TEXT',
+    'ALTER TABLE pick_record ADD COLUMN vol_ratio REAL',
+    'ALTER TABLE price_daily ADD COLUMN run_at TEXT',
+  ]) {
+    try { await client.query(sql); } catch (_) { /* 列已存在则忽略 */ }
+  }
+}
+
+async function persistSnap(snap, d1) {
+  const { run, picks, prices, base } = normalizeSnap(snap);
+  await ensureColumns(d1);
+
+  await d1.query(RUN_Q, [
+    run.anchor_date, run.target_date, run.run_at, run.universe_count, run.r01_count,
+    run.r07_count, run.r05_count, run.high_count, run.secondary_count,
+    run.conditional_count, run.excluded_count, run.kline_fail_rate, run.source, run.note,
+  ]);
+  const rows = await d1.query(RUN_SEL, [run.anchor_date]);
+  const runId = rows[0] && rows[0].id;
+  if (!runId) throw new Error('无法获取 run_id: ' + run.anchor_date);
+
+  const stmts = [];
+  for (const p of picks) {
+    stmts.push({ sql: PICK_Q, params: [
+      runId, p.anchor_date, p.code, p.name, p.sector, p.tier, p.r01_ok, p.r07_laggard,
+      p.r05_partial, p.core, p.r01_chg, p.price, p.turnover, p.vol_ratio, p.circ_market_cap,
+      p.total_market_cap, p.sector_pct, p.sector_rank, p.reason, p.picked_at, run.run_at,
+    ] });
+  }
+  for (const pr of prices) {
+    stmts.push({ sql: PRICE_Q, params: [
+      pr.code, pr.date, pr.open, pr.high, pr.low, pr.close, pr.chg_pct,
+      pr.turnover, pr.circ_market_cap, pr.total_market_cap, run.run_at,
+    ] });
+  }
+  for (const b of base) {
+    stmts.push({ sql: BASE_Q, params: [b.code, b.name, b.sector, b.updated_at] });
+  }
+  await d1.batch(stmts);
+
+  return { runId, picks: picks.length, prices: prices.length, base: base.length };
+}
+
+module.exports = { persistSnap };

package/db/query_local.js

@@ -0,0 +1,43 @@
+'use strict';
+// 本地 SQLite 查询助手：把传入的 SQL 跑在 db/local.db 上并以表格打印。
+// 用法：
+//   node db/query_local.js                         # 打印内置概览（批次 / 分类分布）
+//   node db/query_local.js "SELECT * FROM run_batch ORDER BY anchor_date"
+//   node db/query_local.js "SELECT code,name,tier,reason FROM pick_record WHERE code='sz002594'"
+// 仅允许读语句（SELECT/WITH），避免误改本地库。
+const localSqlite = require('./sqlite_client');
+
+const sql = process.argv.slice(2).join(' ').trim();
+const client = localSqlite.createClient();
+
+function table(rows) {
+  if (!rows.length) { console.log('(空结果)'); return; }
+  const cols = Object.keys(rows[0]);
+  const w = cols.map(c => Math.max(c.length, ...rows.map(r => String(r[c] ?? '').length)));
+  const sep = cols.map((c, i) => '-'.repeat(w[i])).join('-+-');
+  console.log(cols.map((c, i) => String(c).padEnd(w[i])).join(' | '));
+  console.log(sep);
+  for (const r of rows) console.log(cols.map((c, i) => String(r[c] ?? '').padEnd(w[i])).join(' | '));
+}
+
+(async () => {
+  let rows;
+  if (!sql) {
+    console.log('=== 运行批次（run_batch）===');
+    table(await client.query('SELECT anchor_date, universe_count, high_count, secondary_count, conditional_count, excluded_count FROM run_batch ORDER BY anchor_date'));
+    console.log('\n=== 入选分类分布（pick_record）===');
+    table(await client.query("SELECT tier, COUNT(*) c FROM pick_record GROUP BY tier ORDER BY c DESC"));
+    const b = await client.query('SELECT COUNT(*) c FROM stock_base');
+    console.log('\nstock_base 档案数:', (b[0] && b[0].c) || 0);
+    // 多次入选（复盘重点）
+    console.log('\n=== 多次入选的票（同票跨 run）===');
+    table(await client.query("SELECT code, name, COUNT(DISTINCT run_id) runs, GROUP_CONCAT(DISTINCT anchor_date) dates FROM pick_record GROUP BY code HAVING runs > 1 ORDER BY runs DESC LIMIT 20"));
+  } else {
+    if (!/^\s*(SELECT|WITH|PRAGMA|EXPLAIN|VALUES)\b/i.test(sql)) {
+      console.error('只允许只读查询（SELECT / WITH / PRAGMA）。'); process.exit(1);
+    }
+    rows = await client.query(sql);
+    table(rows);
+  }
+  if (client.close) client.close();
+})().catch(e => { console.error('查询失败:', e.message); process.exit(1); });