@zhin.js/plugin-lottery 1.0.0

package/src/stats/pro-analysis.ts

@@ -0,0 +1,136 @@
+import { DEFAULT_WEIGHTS, type DrawNumbers, type GameId, type NormalizedDraw, type ScoreWeights } from '../types.js';
+
+import { formatWeights, normalizeWeights } from './weights.js';
+import { stableHash } from './engine.js';
+
+const RECENT_WINDOW = 30;
+
+export function affinityOfNumbers(
+  nums: number[],
+  freqMap: Map<number, number>,
+  omitMap: Map<number, number>,
+  trendMap: Map<number, number>,
+): ScoreWeights {
+  if (!nums.length) return { ...DEFAULT_WEIGHTS };
+  let f = 0;
+  let o = 0;
+  let t = 0;
+  for (const n of nums) {
+    f += freqMap.get(n) ?? 0;
+    o += omitMap.get(n) ?? 0;
+    t += trendMap.get(n) ?? 0;
+  }
+  const div = nums.length;
+  return normalizeWeights({ freq: f / div, omit: o / div, trend: t / div });
+}
+
+export function buildOmitMap(draws: number[][], poolMin: number, poolMax: number): Map<number, number> {
+  const lastSeen = new Map<number, number>();
+  for (let i = poolMin; i <= poolMax; i++) lastSeen.set(i, draws.length);
+  draws.forEach((nums, idx) => {
+    for (const n of nums) {
+      if (n >= poolMin && n <= poolMax) lastSeen.set(n, idx);
+    }
+  });
+  const maxOmit = Math.max(1, ...lastSeen.values());
+  const out = new Map<number, number>();
+  for (let i = poolMin; i <= poolMax; i++) out.set(i, (lastSeen.get(i) ?? 0) / maxOmit);
+  return out;
+}
+
+export function buildFreqMap(draws: number[][], poolMin: number, poolMax: number): Map<number, number> {
+  const freq = new Map<number, number>();
+  for (let i = poolMin; i <= poolMax; i++) freq.set(i, 0);
+  for (const row of draws) {
+    for (const n of row) {
+      if (n >= poolMin && n <= poolMax) freq.set(n, (freq.get(n) ?? 0) + 1);
+    }
+  }
+  const max = Math.max(1, ...freq.values());
+  for (const [k, v] of freq) freq.set(k, v / max);
+  return freq;
+}
+
+export function computeProMetrics(
+  gameId: GameId,
+  pick: number[],
+  draws: NormalizedDraw[],
+  weights: ScoreWeights,
+  poolMin?: number,
+  poolMax?: number,
+  mid?: number,
+): import('../types.js').ProMetrics {
+  const odd = pick.filter((n) => n % 2 === 1).length;
+  const even = pick.length - odd;
+  const m = mid ?? (poolMax && poolMin ? Math.floor((poolMin + poolMax) / 2) : 5);
+  const big = pick.filter((n) => n > m).length;
+  const small = pick.length - big;
+  const sum = pick.reduce((a, b) => a + b, 0);
+  const span = pick.length ? Math.max(...pick) - Math.min(...pick) : 0;
+
+  let zones: string | undefined;
+  if (poolMin != null && poolMax != null && gameId !== 'fc3d' && gameId !== 'pl3' && gameId !== 'pl5') {
+    const size = Math.ceil((poolMax - poolMin + 1) / 3);
+    const z = [0, 0, 0];
+    for (const n of pick) {
+      const idx = Math.min(2, Math.floor((n - poolMin) / size));
+      z[idx] = (z[idx] ?? 0) + 1;
+    }
+    zones = `三区 ${z.join(':')}`;
+  }
+
+  const rows = draws.map((d) => extractFlat(d.numbers, gameId)).filter((a) => a.length);
+  const recent = rows.slice(0, 10).flat();
+  const freq = new Map<number, number>();
+  for (const n of recent) freq.set(n, (freq.get(n) ?? 0) + 1);
+  const recentHot = [...freq.entries()]
+    .sort((a, b) => b[1] - a[1] || stableHash(`hot:${a[0]}`) - stableHash(`hot:${b[0]}`))
+    .slice(0, 5)
+    .map(([n]) => String(n))
+    .join(',');
+
+  return {
+    oddEven: `奇偶 ${odd}:${even}`,
+    bigSmall: `大小 ${big}:${small}`,
+    sum,
+    span,
+    zones,
+    recentHot: recentHot ? `近10期热号 ${recentHot}` : '',
+    modelWeights: `权重 ${formatWeights(weights)}`,
+  };
+}
+
+export function computeDigitProMetrics(
+  digits: number[],
+  draws: NormalizedDraw[],
+  weights: ScoreWeights,
+): import('../types.js').ProMetrics {
+  const sum = digits.reduce((a, b) => a + b, 0);
+  const span = digits.length ? Math.max(...digits) - Math.min(...digits) : 0;
+  const posHints: string[] = [];
+  const rows = draws.map((d) => d.numbers.digits ?? []).filter((a) => a.length);
+  for (let pos = 0; pos < digits.length; pos++) {
+    const col = rows.map((r) => r[pos]).filter((n) => n !== undefined);
+    const freq = new Map<number, number>();
+    for (let d = 0; d <= 9; d++) freq.set(d, 0);
+    col.slice(0, RECENT_WINDOW).forEach((n) => freq.set(n, (freq.get(n) ?? 0) + 1));
+    const top = [...freq.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([d]) => d);
+    posHints.push(`第${pos + 1}位[${top.join(',')}]`);
+  }
+  return {
+    oddEven: '',
+    bigSmall: '',
+    sum,
+    span,
+    digitPos: posHints.join(' '),
+    recentHot: '',
+    modelWeights: `权重 ${formatWeights(weights)}`,
+  };
+}
+
+function extractFlat(n: DrawNumbers, gameId: GameId): number[] {
+  if (gameId === 'kl8') return n.main ?? [];
+  if (gameId === 'ssq') return n.red ?? [];
+  if (gameId === 'dlt') return n.front ?? [];
+  return n.digits ?? [];
+}

package/src/stats/weights.ts

@@ -0,0 +1,29 @@
+import { DEFAULT_WEIGHTS, type ScoreWeights } from '../types.js';
+
+export function normalizeWeights(w: ScoreWeights | undefined): ScoreWeights {
+  const src = w ?? DEFAULT_WEIGHTS;
+  const freq = Math.max(0.1, src.freq);
+  const omit = Math.max(0.1, src.omit);
+  const trend = Math.max(0.1, src.trend);
+  const sum = freq + omit + trend;
+  return { freq: freq / sum, omit: omit / sum, trend: trend / sum };
+}
+
+export function formatWeights(w: ScoreWeights | undefined): string {
+  const n = normalizeWeights(w);
+  return `F${Math.round(n.freq * 100)} O${Math.round(n.omit * 100)} T${Math.round(n.trend * 100)}`;
+}
+
+export function clampWeight(v: number, min = 0.1, max = 0.6): number {
+  return Math.min(max, Math.max(min, v));
+}
+
+export function mergeWeights(current: ScoreWeights, target: ScoreWeights, lr = 0.05): ScoreWeights {
+  return normalizeWeights({
+    freq: clampWeight(current.freq + lr * (target.freq - current.freq)),
+    omit: clampWeight(current.omit + lr * (target.omit - current.omit)),
+    trend: clampWeight(current.trend + lr * (target.trend - current.trend)),
+  });
+}
+
+export { DEFAULT_WEIGHTS };

package/src/sync/fetch-official.ts

@@ -0,0 +1,185 @@
+import type { DrawNumbers, GameId, NormalizedDraw } from '../types.js';
+import { parseNumberList } from '../stats/engine.js';
+
+const FUCAI_URL = 'https://www.cwl.gov.cn/cwl_admin/front/cwlkj/search/kjxx/findDrawNotice';
+const TICAI_URL = 'https://webapi.sporttery.cn/gateway/lottery/getHistoryPageListV1.qry';
+const PAGE_SIZE = 30;
+
+const BROWSER_UA =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+
+const FUCAI_REFERER: Record<string, string> = {
+  kl8: 'https://www.cwl.gov.cn/ygkj/wqkjgg/kl8/',
+  ssq: 'https://www.cwl.gov.cn/ygkj/wqkjgg/ssq/',
+  '3d': 'https://www.cwl.gov.cn/ygkj/wqkjgg/3d/',
+};
+
+function fucaiHeaders(fucaiName: string): Record<string, string> {
+  return {
+    'User-Agent': BROWSER_UA,
+    Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'zh-CN,zh;q=0.9',
+    Referer: FUCAI_REFERER[fucaiName] ?? 'https://www.cwl.gov.cn/',
+  };
+}
+
+function ticaiHeaders(): Record<string, string> {
+  return {
+    'User-Agent': BROWSER_UA,
+    Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'zh-CN,zh;q=0.9',
+    Referer: 'https://www.lottery.gov.cn/',
+    Origin: 'https://www.lottery.gov.cn',
+  };
+}
+
+async function fetchJson<T>(
+  url: string,
+  headers: Record<string, string>,
+  fetchImpl: typeof fetch,
+): Promise<T> {
+  const res = await fetchImpl(url, { headers });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return (await res.json()) as T;
+}
+
+export async function fetchFucaiDraws(
+  fucaiName: string,
+  count: number,
+  fetchImpl: typeof fetch = fetch,
+): Promise<NormalizedDraw[]> {
+  const headers = fucaiHeaders(fucaiName);
+  const draws: NormalizedDraw[] = [];
+  let pageNo = 1;
+  while (draws.length < count) {
+    const pageSize = Math.min(PAGE_SIZE, count - draws.length);
+    const params = new URLSearchParams({
+      name: fucaiName,
+      pageNo: String(pageNo),
+      pageSize: String(pageSize),
+      systemType: 'PC',
+      issueCount: '',
+      issueStart: '',
+      issueEnd: '',
+      dayStart: '',
+      dayEnd: '',
+    });
+    const json = await fetchJson<{ state?: number; message?: string; result?: unknown[] }>(
+      `${FUCAI_URL}?${params}`,
+      headers,
+      fetchImpl,
+    );
+    if (json.state !== 0) {
+      throw new Error(json.message ?? `福彩接口 state=${String(json.state)}`);
+    }
+    const batch = (json.result ?? []).map((row) => parseFucaiRow(fucaiName, row));
+    if (!batch.length) break;
+    draws.push(...batch);
+    if (batch.length < pageSize) break;
+    pageNo++;
+  }
+  return draws.slice(0, count);
+}
+
+export async function fetchTicaiDraws(
+  gameNo: string,
+  count: number,
+  fetchImpl: typeof fetch = fetch,
+): Promise<NormalizedDraw[]> {
+  const headers = ticaiHeaders();
+  const draws: NormalizedDraw[] = [];
+  let pageNo = 1;
+  while (draws.length < count) {
+    const pageSize = Math.min(PAGE_SIZE, count - draws.length);
+    const params = new URLSearchParams({
+      gameNo,
+      provinceId: '0',
+      pageSize: String(pageSize),
+      pageNo: String(pageNo),
+      isVerify: '1',
+    });
+    const json = await fetchJson<{
+      success?: boolean;
+      errorMessage?: string;
+      value?: { list?: unknown[] };
+    }>(`${TICAI_URL}?${params}`, headers, fetchImpl);
+    if (json.success === false) {
+      throw new Error(json.errorMessage ?? '体彩接口返回失败');
+    }
+    const batch = (json.value?.list ?? []).map((row) => parseTicaiRow(gameNo, row));
+    if (!batch.length) break;
+    draws.push(...batch);
+    if (batch.length < pageSize) break;
+    pageNo++;
+  }
+  return draws.slice(0, count);
+}
+
+function parseFucaiRow(fucaiName: string, row: unknown): NormalizedDraw {
+  const r = row as Record<string, string>;
+  const issue = String(r.code ?? r.issue ?? '');
+  const drawTime = String(r.date ?? r.opentime ?? '').replace(/\([^)]*\)$/, '');
+  const gameId = fucaiNameToGameId(fucaiName);
+  const numbers = parseFucaiNumbers(gameId, r);
+  return { gameId, issue, drawTime, numbers, source: 'fucai' };
+}
+
+function fucaiNameToGameId(name: string): GameId {
+  if (name === 'kl8') return 'kl8';
+  if (name === 'ssq') return 'ssq';
+  return 'fc3d';
+}
+
+function parseFucaiNumbers(gameId: GameId, r: Record<string, string>): DrawNumbers {
+  if (gameId === 'kl8') {
+    const raw = r.red ?? r.kjhyjsx ?? r.kjSpare ?? r.number ?? '';
+    return { main: parseNumberList(raw) };
+  }
+  if (gameId === 'ssq') {
+    return {
+      red: parseNumberList(r.red),
+      blue: parseNumberList(r.blue),
+    };
+  }
+  const digits = parseNumberList(r.red ?? r.code ?? '');
+  if (digits.length >= 3) return { digits: digits.slice(0, 3) };
+  const s = String(r.red ?? r.code ?? '').replace(/\D/g, '');
+  return { digits: [...s].slice(0, 3).map((c) => Number.parseInt(c, 10)) };
+}
+
+function parseTicaiRow(gameNo: string, row: unknown): NormalizedDraw {
+  const r = row as Record<string, string>;
+  const issue = String(r.lotteryDrawNum ?? r.issue ?? '');
+  const drawTime = String(r.lotteryDrawTime ?? r.drawTime ?? '').split(' ')[0] ?? '';
+  const gameId = ticaiGameNoToGameId(gameNo);
+  const numbers = parseTicaiNumbers(gameId, r);
+  return { gameId, issue, drawTime, numbers, source: 'ticai' };
+}
+
+function ticaiGameNoToGameId(gameNo: string): GameId {
+  if (gameNo === '85') return 'dlt';
+  if (gameNo === '35') return 'pl3';
+  return 'pl5';
+}
+
+function parseTicaiNumbers(gameId: GameId, r: Record<string, string>): DrawNumbers {
+  const result = String(r.lotteryDrawResult ?? r.number ?? '');
+  if (gameId === 'dlt') {
+    if (result.includes('+')) {
+      const [frontRaw, backRaw] = result.split('+').map((s) => s.trim());
+      return {
+        front: parseNumberList(frontRaw),
+        back: parseNumberList(backRaw),
+      };
+    }
+    const nums = parseNumberList(result);
+    return { front: nums.slice(0, 5), back: nums.slice(5, 7) };
+  }
+  const digits = result
+    .replace(/\D/g, '')
+    .split('')
+    .map((c) => Number.parseInt(c, 10))
+    .filter((n) => Number.isFinite(n));
+  const len = gameId === 'pl5' ? 5 : 3;
+  return { digits: digits.slice(0, len) };
+}

package/src/sync/run-sync.ts

@@ -0,0 +1,33 @@
+import type { GameId, NormalizedDraw } from '../types.js';
+import { syncGame, type LotteryDb } from '../db.js';
+
+export async function runDataSync(
+  getDb: () => LotteryDb | null,
+  enabledGames: () => GameId[],
+  historyLimit: number,
+  gameId?: GameId,
+): Promise<{ text: string; newSummary: string; inserted: NormalizedDraw[] }> {
+  const db = getDb();
+  if (!db) return { text: 'db not ready', newSummary: '', inserted: [] };
+  const ids = gameId ? [gameId] : enabledGames();
+  const parts: string[] = [];
+  const newParts: string[] = [];
+  const inserted: NormalizedDraw[] = [];
+  for (const id of ids) {
+    try {
+      const { count, inserted: ins } = await syncGame(db, id, historyLimit);
+      parts.push(`${id}:+${count}`);
+      inserted.push(...ins);
+      if (ins.length) {
+        newParts.push(`${id}:${ins.map((d) => d.issue).join(',')}`);
+      }
+    } catch {
+      parts.push(`${id}:err`);
+    }
+  }
+  return {
+    text: `sync ${parts.join(', ')}`,
+    newSummary: newParts.join('; '),
+    inserted,
+  };
+}

package/src/types.ts

@@ -0,0 +1,98 @@
+export type GameId = 'kl8' | 'ssq' | 'dlt' | 'fc3d' | 'pl3' | 'pl5';
+
+export type LotterySource = 'fucai' | 'ticai';
+
+export interface DrawNumbers {
+  main?: number[];
+  red?: number[];
+  blue?: number[];
+  front?: number[];
+  back?: number[];
+  digits?: number[];
+}
+
+export interface NormalizedDraw {
+  gameId: GameId;
+  issue: string;
+  drawTime: string;
+  numbers: DrawNumbers;
+  source: LotterySource;
+}
+
+/** 打分权重：频率 / 遗漏 / 近期趋势 */
+export interface ScoreWeights {
+  freq: number;
+  omit: number;
+  trend: number;
+}
+
+export interface ProMetrics {
+  oddEven: string;
+  bigSmall: string;
+  sum: number;
+  span: number;
+  zones?: string;
+  digitPos?: string;
+  recentHot: string;
+  modelWeights: string;
+}
+
+export interface AccuracySnapshot {
+  evalCount: number;
+  avgHitRate: number;
+  recent5: string;
+}
+
+export interface StatsSnapshot {
+  gameId: GameId;
+  sampleSize: number;
+  hot: string[];
+  cold: string[];
+  detail: string;
+  pro?: ProMetrics;
+  accuracy?: AccuracySnapshot;
+}
+
+export interface GamePick {
+  gameId: GameId;
+  label: string;
+  numbers: DrawNumbers;
+  stats: StatsSnapshot;
+  weights: ScoreWeights;
+  /** KL8 multi-strategy rows (primary numbers still in numbers.main) */
+  kl8Groups?: Kl8PickGroup[];
+}
+
+export type Kl8GroupStrategy = 'balanced' | 'hot' | 'cold' | 'trend';
+
+export interface Kl8PickGroup {
+  index: number;
+  strategy: Kl8GroupStrategy;
+  label: string;
+  numbers: number[];
+  weights: ScoreWeights;
+}
+
+export interface HitSummary {
+  total: number;
+  hits: number;
+  rate: number;
+  detail: string;
+}
+
+export interface DailyReport {
+  date: string;
+  picks: GamePick[];
+  disclaimer: string;
+  accuracyOverview?: string;
+  backtestOverview?: string;
+  /** games that used DEFAULT due to holdout guard */
+  weightFallbackGames?: GameId[];
+  /** Agent 生成的完整正文（优先展示） */
+  body?: string;
+}
+
+export const DISCLAIMER =
+  '免责声明：本推荐由历史数据统计生成，仅供参考，不构成投注建议，不保证中奖。请理性购彩。';
+
+export const DEFAULT_WEIGHTS: ScoreWeights = { freq: 0.4, omit: 0.35, trend: 0.25 };