@zhin.js/plugin-lottery 1.0.0

package/src/recommend/game-pick.ts

@@ -0,0 +1,248 @@
+import { type DrawNumbers, type GameId, type GamePick, type NormalizedDraw, type ScoreWeights, type StatsSnapshot, type AccuracySnapshot } from '../types.js';
+import { getGameMeta } from '../games/registry.js';
+import { recommendKl8Groups, resolveKl8Config, type Kl8Config } from '../games/kl8-groups.js';
+import { pad2, pickTopUnique, scoreDigits, scorePool } from '../stats/engine.js';
+import { computeDigitProMetrics, computeProMetrics } from '../stats/pro-analysis.js';
+
+function buildSnapshot(
+  gameId: GameId,
+  draws: NormalizedDraw[],
+  hot: number[],
+  cold: number[],
+  detail: string,
+  pro: StatsSnapshot['pro'],
+  accuracy?: AccuracySnapshot,
+  _weights?: ScoreWeights,
+): StatsSnapshot {
+  return {
+    gameId,
+    sampleSize: draws.length,
+    hot: hot.map(String),
+    cold: cold.map(String),
+    detail,
+    pro,
+    accuracy,
+  };
+}
+
+function poolDraws(draws: NormalizedDraw[], extract: (n: DrawNumbers) => number[]): number[][] {
+  return draws.map((d) => extract(d.numbers)).filter((a) => a.length > 0);
+}
+
+export interface RecommendOptions {
+  pickCount: number;
+  tieSeed: string;
+  weights?: ScoreWeights;
+  accuracy?: AccuracySnapshot;
+  kl8?: Kl8Config;
+}
+
+export function recommendGame(
+  gameId: GameId,
+  draws: NormalizedDraw[],
+  options: RecommendOptions,
+): GamePick {
+  const meta = getGameMeta(gameId);
+  const tieSeed = `${options.tieSeed}:${gameId}`;
+  const weights = options.weights ?? { freq: 0.4, omit: 0.35, trend: 0.25 };
+
+  switch (gameId) {
+    case 'kl8': {
+      const kl8 = options.kl8 ?? resolveKl8Config(options.pickCount);
+      const rows = poolDraws(draws, (n) => n.main ?? []);
+      if (kl8.recommendGroups <= 1) {
+        const scores = scorePool(rows, 1, 80, tieSeed, weights);
+        const pick = pickTopUnique(scores, kl8.pickCount);
+        const hot = scores.slice(0, 5).map((s) => s.value);
+        const cold = [...scores].reverse().slice(0, 5).map((s) => s.value);
+        const pro = computeProMetrics(gameId, pick, draws, weights, 1, 80, 40);
+        return {
+          gameId,
+          label: `${meta.name}（选${pick.length}）`,
+          numbers: { main: pick },
+          weights,
+          stats: buildSnapshot(
+            gameId,
+            draws,
+            hot,
+            cold,
+            `频率+遗漏+趋势 | 和值${pro.sum} 跨度${pro.span}`,
+            pro,
+            options.accuracy,
+            weights,
+          ),
+        };
+      }
+      const multi = recommendKl8Groups(draws, {
+        pickCount: kl8.pickCount,
+        recommendGroups: kl8.recommendGroups,
+        strategies: kl8.groupStrategies,
+        tieSeed,
+        baseWeights: weights,
+      });
+      const primary = multi.groups[0]?.numbers ?? [];
+      const hot = multi.scores.slice(0, 5).map((s) => s.value);
+      const cold = [...multi.scores].reverse().slice(0, 5).map((s) => s.value);
+      const pro = computeProMetrics(gameId, primary, draws, weights, 1, 80, 40);
+      const strategyNote = multi.groups.map((g) => g.label).join('/');
+      return {
+        gameId,
+        label: `${meta.name}（选${kl8.pickCount}·${multi.groups.length}组）`,
+        numbers: { main: primary },
+        weights,
+        kl8Groups: multi.groups,
+        stats: buildSnapshot(
+          gameId,
+          draws,
+          hot,
+          cold,
+          `多策略 ${strategyNote} | 和值${pro.sum} 跨度${pro.span}`,
+          pro,
+          options.accuracy,
+          weights,
+        ),
+      };
+    }
+    case 'ssq': {
+      const redRows = poolDraws(draws, (n) => n.red ?? []);
+      const blueRows = poolDraws(draws, (n) => n.blue ?? []);
+      const redScores = scorePool(redRows, 1, 33, `${tieSeed}:red`, weights);
+      const blueScores = scorePool(blueRows, 1, 16, `${tieSeed}:blue`, weights);
+      const red = pickTopUnique(redScores, 6);
+      const blue = pickTopUnique(blueScores, 1);
+      const pro = computeProMetrics(gameId, red, draws, weights, 1, 33, 17);
+      return {
+        gameId,
+        label: meta.name,
+        numbers: { red, blue },
+        weights,
+        stats: buildSnapshot(
+          gameId,
+          draws,
+          redScores.slice(0, 5).map((s) => s.value),
+          redScores.slice(-5).map((s) => s.value),
+          `红球 ${pro.oddEven} ${pro.bigSmall} | 蓝 ${blue.map(pad2).join(' ')}`,
+          pro,
+          options.accuracy,
+          weights,
+        ),
+      };
+    }
+    case 'dlt': {
+      const frontRows = poolDraws(draws, (n) => n.front ?? []);
+      const backRows = poolDraws(draws, (n) => n.back ?? []);
+      const frontScores = scorePool(frontRows, 1, 35, `${tieSeed}:front`, weights);
+      const backScores = scorePool(backRows, 1, 12, `${tieSeed}:back`, weights);
+      const front = pickTopUnique(frontScores, 5);
+      const back = pickTopUnique(backScores, 2);
+      const pro = computeProMetrics(gameId, front, draws, weights, 1, 35, 18);
+      return {
+        gameId,
+        label: meta.name,
+        numbers: { front, back },
+        weights,
+        stats: buildSnapshot(
+          gameId,
+          draws,
+          frontScores.slice(0, 5).map((s) => s.value),
+          frontScores.slice(-5).map((s) => s.value),
+          `前区 ${pro.oddEven} ${pro.zones ?? ''}`.trim(),
+          pro,
+          options.accuracy,
+          weights,
+        ),
+      };
+    }
+    case 'fc3d':
+    case 'pl3': {
+      const rows = poolDraws(draws, (n) => n.digits ?? []);
+      const digits = scoreDigits(rows, 3, tieSeed, weights);
+      const pro = computeDigitProMetrics(digits, draws, weights);
+      return {
+        gameId,
+        label: meta.name,
+        numbers: { digits },
+        weights,
+        stats: buildSnapshot(
+          gameId,
+          draws,
+          digits,
+          [],
+          `直选 ${pro.digitPos} | 和值${pro.sum}`,
+          pro,
+          options.accuracy,
+          weights,
+        ),
+      };
+    }
+    case 'pl5': {
+      const rows = poolDraws(draws, (n) => n.digits ?? []);
+      const digits = scoreDigits(rows, 5, tieSeed, weights);
+      const pro = computeDigitProMetrics(digits, draws, weights);
+      return {
+        gameId,
+        label: meta.name,
+        numbers: { digits },
+        weights,
+        stats: buildSnapshot(
+          gameId,
+          draws,
+          digits,
+          [],
+          `直选 ${pro.digitPos} | 和值${pro.sum}`,
+          pro,
+          options.accuracy,
+          weights,
+        ),
+      };
+    }
+    default:
+      throw new Error(`Unsupported game ${gameId}`);
+  }
+}
+
+export function formatPickLine(pick: GamePick): string {
+  const n = pick.numbers;
+  switch (pick.gameId) {
+    case 'kl8': {
+      if (pick.kl8Groups?.length) {
+        const header = `■ ${pick.label}`;
+        const rows = pick.kl8Groups.map(
+          (g) => `  组${g.index}·${g.label}：${g.numbers.map(pad2).join(' ')}`,
+        );
+        return [header, ...rows].join('\n');
+      }
+      return `■ ${pick.label}：${(n.main ?? []).map(pad2).join(' ')}`;
+    }
+    case 'ssq':
+      return `■ ${pick.label}：红 ${(n.red ?? []).map(pad2).join(' ')} + 蓝 ${(n.blue ?? []).map(pad2).join(' ')}`;
+    case 'dlt':
+      return `■ ${pick.label}：前 ${(n.front ?? []).map(pad2).join(' ')} + 后 ${(n.back ?? []).map(pad2).join(' ')}`;
+    case 'fc3d':
+    case 'pl3':
+    case 'pl5':
+      return `■ ${pick.label}：${(n.digits ?? []).join(' ')}`;
+    default:
+      return `■ ${pick.label}`;
+  }
+}
+
+export function formatPickStats(pick: GamePick): string {
+  const parts: string[] = [];
+  const hot = pick.stats.hot.length ? `热号 ${pick.stats.hot.join(',')}` : '';
+  const cold = pick.stats.cold.length ? `冷号 ${pick.stats.cold.join(',')}` : '';
+  if (hot) parts.push(hot);
+  if (cold) parts.push(cold);
+  if (pick.stats.pro) {
+    const p = pick.stats.pro;
+    const morph = [p.oddEven, p.bigSmall, p.zones, p.recentHot, p.modelWeights].filter(Boolean).join(' | ');
+    if (morph) parts.push(morph);
+    if (p.digitPos) parts.push(p.digitPos);
+  }
+  if (pick.stats.accuracy) {
+    const a = pick.stats.accuracy;
+    parts.push(`历史命中 ${(a.avgHitRate * 100).toFixed(1)}% (${a.evalCount}期) 近5期 ${a.recent5}`);
+  }
+  parts.push(pick.stats.detail);
+  return `  ${parts.filter(Boolean).join('\n  ')}`;
+}

package/src/recommend/report.ts

@@ -0,0 +1,211 @@
+import { DEFAULT_WEIGHTS, DISCLAIMER, type DailyReport, type DrawNumbers, type GameId, type GamePick, type ScoreWeights } from '../types.js';
+
+import { recommendGame, formatPickLine, formatPickStats } from './game-pick.js';
+import { resolveKl8Config, type Kl8Config } from '../games/kl8-groups.js';
+
+import { loadDraws, REPORTS_TABLE, parseStoredJson, type LotteryDb } from '../db.js';
+
+import { listPendingPredictions, loadAccuracySnapshot, loadGameWeights, savePrediction } from '../evaluate/tracker.js';
+import { formatWeights } from '../stats/weights.js';
+
+export interface LotteryConfigSlice {
+  pickCount: number;
+  historyLimit: number;
+  kl8?: Kl8Config;
+}
+
+export async function buildDailyReport(
+  db: LotteryDb,
+  gameIds: GameId[],
+  config: LotteryConfigSlice,
+  date = new Date(),
+  savePredictions = true,
+  weightOverrides?: Map<GameId, ScoreWeights>,
+): Promise<DailyReport> {
+  const dateStr = date.toISOString().slice(0, 10);
+  const tieSeed = dateStr;
+  const picks = [];
+  for (const gameId of gameIds) {
+    const draws = await loadDraws(db, gameId, config.historyLimit);
+    if (!draws.length) continue;
+    const weights = weightOverrides?.get(gameId) ?? (await loadGameWeights(db, gameId));
+    const accuracy = await loadAccuracySnapshot(db, gameId);
+    const kl8 = config.kl8 ?? resolveKl8Config(config.pickCount);
+    const pick = recommendGame(gameId, draws, {
+      pickCount: gameId === 'kl8' ? kl8.pickCount : config.pickCount,
+      tieSeed,
+      weights,
+      accuracy,
+      kl8: gameId === 'kl8' ? kl8 : undefined,
+    });
+    picks.push(pick);
+    if (savePredictions) await savePrediction(db, pick, date);
+  }
+  const accuracyOverview = picks
+    .filter((p) => p.stats.accuracy)
+    .map((p) => `${p.gameId} ${((p.stats.accuracy?.avgHitRate ?? 0) * 100).toFixed(1)}%`)
+    .join(' | ');
+  return {
+    date: dateStr,
+    picks,
+    disclaimer: DISCLAIMER,
+    accuracyOverview: accuracyOverview || undefined,
+  };
+}
+
+export function formatDailyReportText(report: DailyReport, aiExplanation?: string): string {
+  if (report.body?.trim()) {
+    const extra = aiExplanation?.trim();
+    return extra ? `${report.body.trim()}\n\n${extra}` : report.body.trim();
+  }
+  const lines = [`【彩票每日推荐】${report.date}`, ''];
+  if (report.backtestOverview?.trim()) {
+    lines.push(report.backtestOverview.trim());
+    lines.push('');
+  }
+  if (report.weightFallbackGames?.length) {
+    lines.push(`【权重保护】近端 holdout 调优未跑赢随机，已回退默认 F40/O35/T25：${report.weightFallbackGames.join(', ')}`);
+    lines.push('');
+  }
+  if (report.accuracyOverview) {
+    lines.push(`【模型复盘】累计平均命中 ${report.accuracyOverview}`);
+    lines.push('');
+  }
+  for (const pick of report.picks) {
+    lines.push(formatPickLine(pick));
+    lines.push(formatPickStats(pick));
+    lines.push('');
+  }
+  if (aiExplanation?.trim()) {
+    lines.push(aiExplanation.trim());
+    lines.push('');
+  } else {
+    lines.push('【统计说明】号码由频率+遗漏+近期趋势综合打分，并根据历史命中自动调权。');
+    lines.push('');
+  }
+  lines.push(report.disclaimer);
+  return lines.join('\n').trim();
+}
+
+export async function saveDailyReport(
+  db: LotteryDb,
+  report: DailyReport,
+  aiExplanation: string,
+): Promise<void> {
+  const model = db.models.get(REPORTS_TABLE);
+  if (!model) return;
+  const existing = await model.select().where({ date: report.date });
+  if (Array.isArray(existing) && existing.length > 0) return;
+  await model.insert({
+    date: report.date,
+    report_json: JSON.stringify(report),
+    ai_explanation: aiExplanation,
+    created_at: new Date().toISOString(),
+  });
+}
+
+export async function loadTodayReport(db: LotteryDb, date = new Date()): Promise<DailyReport | null> {
+  const model = db.models.get(REPORTS_TABLE);
+  if (!model) return null;
+  const dateStr = date.toISOString().slice(0, 10);
+  const rows = (await model.select().where({ date: dateStr })) as Array<{
+    report_json: string | DailyReport;
+    ai_explanation: string;
+  }>;
+  if (!rows.length) return null;
+  const row = rows[0];
+  if (!row) return null;
+  const report = parseStoredJson<DailyReport>(row.report_json, {
+    date: dateStr,
+    picks: [],
+    disclaimer: '',
+  });
+  if (!report.picks?.length && !report.body?.trim()) return null;
+  return report;
+}
+
+/** Today's pending rows as displayable picks (when report table is empty). */
+export async function loadTodayPendingPicks(
+  db: LotteryDb,
+  gameIds: GameId[],
+  date = new Date(),
+): Promise<GamePick[]> {
+  const today = date.toISOString().slice(0, 10);
+  const picks: GamePick[] = [];
+  for (const gameId of gameIds) {
+    const pending = (await listPendingPredictions(db, gameId)) as Array<{
+      predict_date: string;
+      numbers: string | DrawNumbers;
+      weights: string | ScoreWeights;
+    }>;
+    for (const row of pending.filter((p) => p.predict_date === today)) {
+      picks.push({
+        gameId,
+        label: gameId,
+        numbers: parseStoredJson<DrawNumbers>(row.numbers, {}),
+        weights: parseStoredJson<ScoreWeights>(row.weights, DEFAULT_WEIGHTS),
+        stats: { gameId, sampleSize: 0, hot: [], cold: [], detail: '' },
+      });
+    }
+  }
+  return picks;
+}
+
+/** Saved daily report, or reconstruct from today's pending picks. */
+export async function resolveTodayReport(
+  db: LotteryDb,
+  gameIds: GameId[],
+  date = new Date(),
+): Promise<DailyReport | null> {
+  const saved = await loadTodayReport(db, date);
+  if (saved) return saved;
+  const picks = await loadTodayPendingPicks(db, gameIds, date);
+  if (!picks.length) return null;
+  return {
+    date: date.toISOString().slice(0, 10),
+    picks,
+    disclaimer: DISCLAIMER,
+  };
+}
+
+/** Backfill missing pick weights from DB (saved reports may omit weights). */
+export async function hydrateReportPickWeights(db: LotteryDb, picks: GamePick[]): Promise<GamePick[]> {
+  const out: GamePick[] = [];
+  for (const pick of picks) {
+    if (pick.weights?.freq != null && pick.weights?.omit != null && pick.weights?.trend != null) {
+      out.push(pick);
+      continue;
+    }
+    out.push({ ...pick, weights: await loadGameWeights(db, pick.gameId) });
+  }
+  return out;
+}
+
+export async function explainReportWithAi(
+  root: { inject?: (key: string) => unknown },
+  report: DailyReport,
+): Promise<string> {
+  const ai = root.inject?.('ai') as
+    | { ask?: (prompt: string, opts?: { systemPrompt?: string }) => Promise<string> }
+    | undefined;
+  if (!ai?.ask) return '';
+  const summary = report.picks
+    .map((p) => {
+      const acc = p.stats.accuracy
+        ? `历史命中${(p.stats.accuracy.avgHitRate * 100).toFixed(1)}%`
+        : '';
+      const w = p.stats.pro?.modelWeights ?? formatWeights(p.weights);
+      const nums = p.gameId === 'kl8' && p.kl8Groups?.length
+        ? p.kl8Groups.map((g) => `组${g.index}(${g.label}) ${g.numbers.join(',')}`).join('; ')
+        : formatPickLine(p).replace('■ ', '').replace(/\n/g, ' ');
+      return `${p.label}: ${nums} | ${p.stats.detail} | ${w} | ${acc}`;
+    })
+    .join('\n');
+  const systemPrompt =
+    '你是专业彩票数据分析师。根据统计形态、模型权重与历史命中率写解读（250字内）。不得修改推荐号码。';
+  try {
+    return await ai.ask(`请专业解读以下推荐：\n\n${summary}`, { systemPrompt });
+  } catch {
+    return '';
+  }
+}

package/src/stats/engine.ts

@@ -0,0 +1,143 @@
+import { DEFAULT_WEIGHTS, type ScoreWeights } from '../types.js';
+
+import { normalizeWeights } from './weights.js';
+
+const RECENT_WINDOW = 30;
+
+export function analyzePoolTrend(draws: number[][], poolMin: number, poolMax: number): Map<number, number> {
+  const recent = draws.slice(0, RECENT_WINDOW);
+  const freq = new Map<number, number>();
+  for (let i = poolMin; i <= poolMax; i++) freq.set(i, 0);
+  for (const row of recent) {
+    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 parseNumberList(raw: string | undefined | null): number[] {
+  if (!raw) return [];
+  return raw
+    .split(/[,，\s+|]+/)
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .map((s) => Number.parseInt(s, 10))
+    .filter((n) => Number.isFinite(n));
+}
+
+export function stableHash(seed: string): number {
+  let h = 0;
+  for (let i = 0; i < seed.length; i++) {
+    h = (h * 31 + seed.charCodeAt(i)) >>> 0;
+  }
+  return h;
+}
+
+export interface PoolScore {
+  value: number;
+  freq: number;
+  omit: number;
+  trend: number;
+  score: number;
+}
+
+/** 号码池：频率 + 遗漏 + 近期趋势 综合打分 */
+export function scorePool(
+  draws: number[][],
+  poolMin: number,
+  poolMax: number,
+  tieSeed: string,
+  weights: ScoreWeights = DEFAULT_WEIGHTS,
+): PoolScore[] {
+  const w = normalizeWeights(weights);
+  const freq = new Map<number, number>();
+  const lastSeen = new Map<number, number>();
+  for (let i = poolMin; i <= poolMax; i++) {
+    freq.set(i, 0);
+    lastSeen.set(i, draws.length);
+  }
+  draws.forEach((nums, idx) => {
+    for (const n of nums) {
+      if (n < poolMin || n > poolMax) continue;
+      freq.set(n, (freq.get(n) ?? 0) + 1);
+      lastSeen.set(n, idx);
+    }
+  });
+  const trend = analyzePoolTrend(draws, poolMin, poolMax);
+  const maxFreq = Math.max(1, ...freq.values());
+  const maxOmit = Math.max(1, ...lastSeen.values());
+  const scores: PoolScore[] = [];
+  for (let v = poolMin; v <= poolMax; v++) {
+    const f = (freq.get(v) ?? 0) / maxFreq;
+    const o = (lastSeen.get(v) ?? 0) / maxOmit;
+    const t = trend.get(v) ?? 0;
+    scores.push({
+      value: v,
+      freq: f,
+      omit: o,
+      trend: t,
+      score: f * w.freq + o * w.omit + t * w.trend,
+    });
+  }
+  scores.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return stableHash(`${tieSeed}:${a.value}`) - stableHash(`${tieSeed}:${b.value}`);
+  });
+  return scores;
+}
+
+export function pickTopUnique(scores: PoolScore[], count: number): number[] {
+  return scores.slice(0, count).map((s) => s.value).sort((a, b) => a - b);
+}
+
+/** 定位胆：每位 0-9 独立打分（含近期趋势） */
+export function scoreDigits(
+  draws: number[][],
+  positions: number,
+  tieSeed: string,
+  weights: ScoreWeights = DEFAULT_WEIGHTS,
+): number[] {
+  const w = normalizeWeights(weights);
+  const picks: number[] = [];
+  for (let pos = 0; pos < positions; pos++) {
+    const column = draws.map((d) => d[pos]).filter((n) => n !== undefined);
+    const recent = column.slice(0, 30);
+    const freq = new Map<number, number>();
+    const lastSeen = new Map<number, number>();
+    const trend = new Map<number, number>();
+    for (let i = 0; i <= 9; i++) {
+      freq.set(i, 0);
+      lastSeen.set(i, column.length);
+      trend.set(i, 0);
+    }
+    column.forEach((n, idx) => {
+      freq.set(n, (freq.get(n) ?? 0) + 1);
+      lastSeen.set(n, idx);
+    });
+    recent.forEach((n) => trend.set(n, (trend.get(n) ?? 0) + 1));
+    const maxFreq = Math.max(1, ...freq.values());
+    const maxOmit = Math.max(1, ...lastSeen.values());
+    const maxTrend = Math.max(1, ...trend.values());
+    let best = 0;
+    let bestScore = -1;
+    for (let d = 0; d <= 9; d++) {
+      const f = (freq.get(d) ?? 0) / maxFreq;
+      const o = (lastSeen.get(d) ?? 0) / maxOmit;
+      const t = (trend.get(d) ?? 0) / maxTrend;
+      const score = f * w.freq + o * w.omit + t * w.trend;
+      if (score > bestScore || (score === bestScore && stableHash(`${tieSeed}:${pos}:${d}`) < stableHash(`${tieSeed}:${pos}:${best}`))) {
+        bestScore = score;
+        best = d;
+      }
+    }
+    picks.push(best);
+  }
+  return picks;
+}
+
+export function pad2(n: number): string {
+  return n < 10 ? `0${n}` : String(n);
+}