gaokao-pro 0.1.0

package/dist/codes.d.ts

@@ -0,0 +1,162 @@
+export declare const PROVINCES: {
+    readonly 11: {
+        readonly name: "北京";
+        readonly pinyin: "beijing";
+        readonly reform: "3+3";
+    };
+    readonly 12: {
+        readonly name: "天津";
+        readonly pinyin: "tianjin";
+        readonly reform: "3+3";
+    };
+    readonly 13: {
+        readonly name: "河北";
+        readonly pinyin: "hebei";
+        readonly reform: "3+1+2";
+    };
+    readonly 14: {
+        readonly name: "山西";
+        readonly pinyin: "shanxi";
+        readonly reform: "old";
+    };
+    readonly 15: {
+        readonly name: "内蒙古";
+        readonly pinyin: "neimenggu";
+        readonly reform: "old";
+    };
+    readonly 21: {
+        readonly name: "辽宁";
+        readonly pinyin: "liaoning";
+        readonly reform: "3+1+2";
+    };
+    readonly 22: {
+        readonly name: "吉林";
+        readonly pinyin: "jilin";
+        readonly reform: "3+1+2";
+    };
+    readonly 23: {
+        readonly name: "黑龙江";
+        readonly pinyin: "heilongjiang";
+        readonly reform: "3+1+2";
+    };
+    readonly 31: {
+        readonly name: "上海";
+        readonly pinyin: "shanghai";
+        readonly reform: "3+3";
+    };
+    readonly 32: {
+        readonly name: "江苏";
+        readonly pinyin: "jiangsu";
+        readonly reform: "3+1+2";
+    };
+    readonly 33: {
+        readonly name: "浙江";
+        readonly pinyin: "zhejiang";
+        readonly reform: "3+3";
+    };
+    readonly 34: {
+        readonly name: "安徽";
+        readonly pinyin: "anhui";
+        readonly reform: "3+1+2";
+    };
+    readonly 35: {
+        readonly name: "福建";
+        readonly pinyin: "fujian";
+        readonly reform: "3+1+2";
+    };
+    readonly 36: {
+        readonly name: "江西";
+        readonly pinyin: "jiangxi";
+        readonly reform: "3+1+2";
+    };
+    readonly 37: {
+        readonly name: "山东";
+        readonly pinyin: "shandong";
+        readonly reform: "3+3";
+    };
+    readonly 41: {
+        readonly name: "河南";
+        readonly pinyin: "henan";
+        readonly reform: "3+1+2";
+    };
+    readonly 42: {
+        readonly name: "湖北";
+        readonly pinyin: "hubei";
+        readonly reform: "3+1+2";
+    };
+    readonly 43: {
+        readonly name: "湖南";
+        readonly pinyin: "hunan";
+        readonly reform: "3+1+2";
+    };
+    readonly 44: {
+        readonly name: "广东";
+        readonly pinyin: "guangdong";
+        readonly reform: "3+1+2";
+    };
+    readonly 45: {
+        readonly name: "广西";
+        readonly pinyin: "guangxi";
+        readonly reform: "3+1+2";
+    };
+    readonly 46: {
+        readonly name: "海南";
+        readonly pinyin: "hainan";
+        readonly reform: "3+3";
+    };
+    readonly 50: {
+        readonly name: "重庆";
+        readonly pinyin: "chongqing";
+        readonly reform: "3+1+2";
+    };
+    readonly 51: {
+        readonly name: "四川";
+        readonly pinyin: "sichuan";
+        readonly reform: "3+1+2";
+    };
+    readonly 52: {
+        readonly name: "贵州";
+        readonly pinyin: "guizhou";
+        readonly reform: "3+1+2";
+    };
+    readonly 53: {
+        readonly name: "云南";
+        readonly pinyin: "yunnan";
+        readonly reform: "3+1+2";
+    };
+    readonly 54: {
+        readonly name: "西藏";
+        readonly pinyin: "xizang";
+        readonly reform: "old";
+    };
+    readonly 61: {
+        readonly name: "陕西";
+        readonly pinyin: "shaanxi";
+        readonly reform: "3+1+2";
+    };
+    readonly 62: {
+        readonly name: "甘肃";
+        readonly pinyin: "gansu";
+        readonly reform: "3+1+2";
+    };
+    readonly 63: {
+        readonly name: "青海";
+        readonly pinyin: "qinghai";
+        readonly reform: "3+1+2";
+    };
+    readonly 64: {
+        readonly name: "宁夏";
+        readonly pinyin: "ningxia";
+        readonly reform: "3+1+2";
+    };
+    readonly 65: {
+        readonly name: "新疆";
+        readonly pinyin: "xinjiang";
+        readonly reform: "3+1+2";
+    };
+};
+export type ProvinceId = keyof typeof PROVINCES;
+export declare const TRACK_NAMES: Record<string, string>;
+export declare function resolveProvince(input: string | number): ProvinceId | null;
+export type Subject = "物理" | "历史" | "化学" | "生物" | "政治" | "地理";
+export declare const ALL_SUBJECTS: Subject[];

package/dist/codes.js

@@ -0,0 +1,59 @@
+// Province codes used by static-data.gaokao.cn (GB/T 2260 prefix).
+export const PROVINCES = {
+    11: { name: "北京", pinyin: "beijing", reform: "3+3" },
+    12: { name: "天津", pinyin: "tianjin", reform: "3+3" },
+    13: { name: "河北", pinyin: "hebei", reform: "3+1+2" },
+    14: { name: "山西", pinyin: "shanxi", reform: "old" },
+    15: { name: "内蒙古", pinyin: "neimenggu", reform: "old" },
+    21: { name: "辽宁", pinyin: "liaoning", reform: "3+1+2" },
+    22: { name: "吉林", pinyin: "jilin", reform: "3+1+2" },
+    23: { name: "黑龙江", pinyin: "heilongjiang", reform: "3+1+2" },
+    31: { name: "上海", pinyin: "shanghai", reform: "3+3" },
+    32: { name: "江苏", pinyin: "jiangsu", reform: "3+1+2" },
+    33: { name: "浙江", pinyin: "zhejiang", reform: "3+3" },
+    34: { name: "安徽", pinyin: "anhui", reform: "3+1+2" },
+    35: { name: "福建", pinyin: "fujian", reform: "3+1+2" },
+    36: { name: "江西", pinyin: "jiangxi", reform: "3+1+2" },
+    37: { name: "山东", pinyin: "shandong", reform: "3+3" },
+    41: { name: "河南", pinyin: "henan", reform: "3+1+2" },
+    42: { name: "湖北", pinyin: "hubei", reform: "3+1+2" },
+    43: { name: "湖南", pinyin: "hunan", reform: "3+1+2" },
+    44: { name: "广东", pinyin: "guangdong", reform: "3+1+2" },
+    45: { name: "广西", pinyin: "guangxi", reform: "3+1+2" },
+    46: { name: "海南", pinyin: "hainan", reform: "3+3" },
+    50: { name: "重庆", pinyin: "chongqing", reform: "3+1+2" },
+    51: { name: "四川", pinyin: "sichuan", reform: "3+1+2" },
+    52: { name: "贵州", pinyin: "guizhou", reform: "3+1+2" },
+    53: { name: "云南", pinyin: "yunnan", reform: "3+1+2" },
+    54: { name: "西藏", pinyin: "xizang", reform: "old" },
+    61: { name: "陕西", pinyin: "shaanxi", reform: "3+1+2" },
+    62: { name: "甘肃", pinyin: "gansu", reform: "3+1+2" },
+    63: { name: "青海", pinyin: "qinghai", reform: "3+1+2" },
+    64: { name: "宁夏", pinyin: "ningxia", reform: "3+1+2" },
+    65: { name: "新疆", pinyin: "xinjiang", reform: "3+1+2" }
+};
+// Subject-track codes seen in static-data.gaokao.cn `type` / `pro_type` fields.
+export const TRACK_NAMES = {
+    "1": "理工",
+    "2": "文史",
+    "3": "综合改革", // 3+3 provinces
+    "2073": "物理类", // 3+1+2 物理首选
+    "2074": "历史类" // 3+1+2 历史首选
+};
+export function resolveProvince(input) {
+    if (typeof input === "number") {
+        return (input in PROVINCES) ? input : null;
+    }
+    const trimmed = String(input).trim().toLowerCase();
+    const numeric = Number(trimmed);
+    if (Number.isFinite(numeric) && numeric in PROVINCES) {
+        return numeric;
+    }
+    for (const [id, p] of Object.entries(PROVINCES)) {
+        if (p.name === trimmed || p.pinyin === trimmed) {
+            return Number(id);
+        }
+    }
+    return null;
+}
+export const ALL_SUBJECTS = ["物理", "历史", "化学", "生物", "政治", "地理"];

package/dist/compare.d.ts

@@ -0,0 +1,39 @@
+import { type SchoolAdapter } from "./datasets.js";
+import { type ProvinceId } from "./codes.js";
+export type CompareSide = {
+    name: string;
+    zsCode: string;
+    province: string;
+    city: string;
+    belong: string;
+    labels: string[];
+    rank: {
+        ruanke: string | null;
+        qsWorld: string | null;
+        usNews: string | null;
+        xyh: string | null;
+    };
+    xuekePinggu: Record<string, string>;
+    recentMinScores: Record<string, Array<{
+        year: number;
+        track: string;
+        min: number;
+    }>>;
+    zswUrl: string | null;
+    programs: SchoolAdapter["programs"] | null;
+    contact: SchoolAdapter["contact"] | null;
+};
+export type CompareOutput = {
+    a: CompareSide;
+    b: CompareSide;
+    diff: {
+        labels: {
+            only_a: string[];
+            only_b: string[];
+            both: string[];
+        };
+        ruanke_rank_delta: number | null;
+        province_score_delta?: Record<string, number>;
+    };
+};
+export declare function compare(queryA: string, queryB: string, focusProvince?: ProvinceId): CompareOutput;

package/dist/compare.js

@@ -0,0 +1,112 @@
+// compare — side-by-side comparison of two schools across all surface dimensions.
+//
+// Pulls from the local school-index (for rank/labels/historical scores) and the
+// schools-adapters dataset (for 招生网/special programs). No network.
+//
+// 22 of the 100 candidate-validator agents drafted "A vs B" questions; this
+// verb gives Claude a single call that returns everything those questions need.
+import { loadIndex } from "./index-loader.js";
+import { findSchoolAdapter } from "./datasets.js";
+import { PROVINCES, TRACK_NAMES } from "./codes.js";
+import { resolveAlias } from "./aliases.js";
+function findSchool(rows, query) {
+    const canonical = resolveAlias(query);
+    // exact alias → exact name match
+    if (canonical !== query) {
+        const exact = rows.find((r) => r.name === canonical);
+        if (exact)
+            return exact;
+    }
+    // exact zs_code
+    const byCode = rows.find((r) => r.zs_code === query);
+    if (byCode)
+        return byCode;
+    // exact name
+    const byExact = rows.find((r) => r.name === query);
+    if (byExact)
+        return byExact;
+    // substring, prefer shortest name
+    const substr = rows.filter((r) => r.name.includes(query)).sort((a, b) => a.name.length - b.name.length);
+    return substr[0];
+}
+function buildSide(query, focusProvince) {
+    const index = loadIndex();
+    const row = findSchool(index.rows, query);
+    if (!row)
+        throw new Error(`no school matched "${query}". Try the full Chinese name or zs_code; supported aliases: 清华/北大/复旦/上交/浙大/南大/中科大/哈工大/西交/人大/北航/北理/...`);
+    const adapter = findSchoolAdapter(row.zs_code) ?? findSchoolAdapter(row.name);
+    const labels = [];
+    if (row.f985)
+        labels.push("985");
+    if (row.f211)
+        labels.push("211");
+    if (row.dual_class === "双一流")
+        labels.push("双一流");
+    const rank = {
+        ruanke: null,
+        qsWorld: null,
+        usNews: null,
+        xyh: null
+    };
+    // recent min scores: if focusProvince supplied, only that province; else top 5 provinces.
+    const recentMinScores = {};
+    const provincesToShow = focusProvince ? [String(focusProvince)] : ["11", "31", "44", "41", "37"];
+    for (const provId of provincesToShow) {
+        const entries = row.pro_type_min?.[provId] ?? [];
+        const flat = [];
+        for (const e of entries) {
+            for (const [t, v] of Object.entries(e.type ?? {})) {
+                const n = Number(v);
+                if (Number.isFinite(n) && n > 0) {
+                    flat.push({ year: e.year, track: TRACK_NAMES[t] ?? t, min: n });
+                }
+            }
+        }
+        if (flat.length > 0) {
+            flat.sort((x, y) => y.year - x.year);
+            const provName = PROVINCES[Number(provId)]?.name ?? provId;
+            recentMinScores[provName] = flat.slice(0, 6);
+        }
+    }
+    return {
+        name: row.name,
+        zsCode: row.zs_code,
+        province: row.province,
+        city: row.city,
+        belong: row.belong,
+        labels,
+        rank,
+        xuekePinggu: {},
+        recentMinScores,
+        zswUrl: adapter?.zsw_url ?? null,
+        programs: adapter?.programs ?? null,
+        contact: adapter?.contact ?? null
+    };
+}
+export function compare(queryA, queryB, focusProvince) {
+    const a = buildSide(queryA, focusProvince);
+    const b = buildSide(queryB, focusProvince);
+    const labelsA = new Set(a.labels);
+    const labelsB = new Set(b.labels);
+    const both = a.labels.filter((l) => labelsB.has(l));
+    const onlyA = a.labels.filter((l) => !labelsB.has(l));
+    const onlyB = b.labels.filter((l) => !labelsA.has(l));
+    // Province-score delta (latest matching year per shown province)
+    const provinceScoreDelta = {};
+    for (const prov of Object.keys(a.recentMinScores)) {
+        const aLatest = a.recentMinScores[prov]?.[0];
+        const bLatest = b.recentMinScores[prov]?.[0];
+        if (aLatest && bLatest && aLatest.track === bLatest.track && aLatest.year === bLatest.year) {
+            provinceScoreDelta[prov] = aLatest.min - bLatest.min;
+        }
+    }
+    return {
+        a,
+        b,
+        diff: {
+            labels: { only_a: onlyA, only_b: onlyB, both },
+            ruanke_rank_delta: null,
+            province_score_delta: provinceScoreDelta
+        }
+    };
+}

package/dist/datasets.d.ts

@@ -0,0 +1,65 @@
+export type ProgramFlag = {
+    offers: boolean | null;
+    url: string | null;
+};
+export type GaoxiaoZhuanxiang = {
+    offers: boolean | null;
+    name: string | null;
+    url: string | null;
+};
+export type SchoolAdapter = {
+    name: string;
+    zs_code: string;
+    zsw_url: string | null;
+    programs: {
+        qiangji: ProgramFlag;
+        zonghepingjia: ProgramFlag;
+        zhongwai_hezuo: ProgramFlag;
+        guojia_zhuanxiang: boolean | null;
+        gaoxiao_zhuanxiang: GaoxiaoZhuanxiang;
+        minzu_ban: boolean | null;
+        yuke_ban: boolean | null;
+        gao_shui_yundong: boolean | null;
+        high_art: boolean | null;
+    };
+    contact: {
+        phone: string | null;
+        email: string | null;
+    };
+    note?: string;
+};
+export type SchoolsAdaptersFile = {
+    schools: SchoolAdapter[];
+};
+export type ProvinceSpecialty = {
+    province: string;
+    year: number;
+    data_quality?: "verified" | "partial";
+    tiqian?: {
+        types?: string[];
+        rules?: string;
+    };
+    qiangji_implementing?: string[];
+    zonghepingjia_implementing?: string[];
+    guojia_zhuanxiang?: boolean;
+    gaoxiao_zhuanxiang?: boolean;
+    difang_zhuanxiang?: boolean;
+    source?: string[];
+};
+export type CrossProvincePrograms = {
+    guojia_zhuanxiang?: Record<string, unknown>;
+    gaoxiao_zhuanxiang?: Record<string, unknown>;
+    difang_zhuanxiang?: Record<string, unknown>;
+    gangaotai_lianzhao?: Record<string, unknown>;
+};
+export type ProvincesSpecialtyFile = {
+    provinces: ProvinceSpecialty[];
+    cross_province_special_programs: CrossProvincePrograms;
+};
+export declare function loadSchoolsAdapters(): SchoolsAdaptersFile;
+export declare function loadProvincesSpecialty(): ProvincesSpecialtyFile;
+export declare function findSchoolAdapter(query: string): SchoolAdapter | null;
+export declare function listSchoolsOfferingProgram(program: "qiangji" | "zonghepingjia" | "zhongwai_hezuo" | "guojia_zhuanxiang" | "gaoxiao_zhuanxiang" | "minzu_ban" | "yuke_ban" | "gao_shui_yundong" | "high_art"): SchoolAdapter[];
+export declare function findProvinceSpecialty(provinceKey: string): ProvinceSpecialty | null;
+export declare function listProvinceKeys(): string[];
+export declare function getCrossProvincePrograms(): CrossProvincePrograms;

package/dist/datasets.js

@@ -0,0 +1,82 @@
+// Loaders for the static datasets shipped in cli/data/datasets/.
+// These are the human-curated artifacts produced by the multi-agent fan-outs:
+//   schools-adapters-2024.json: per-school 招生网 URL + 强基/综评/中外/专项/民族/预科/运动/艺术 flags
+//   provinces-specialty-2024.json: per-province 提前批 + cross-province 国家/高校/地方专项 + 港澳台联招
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const SRC_DIR = dirname(__filename);
+const CANDIDATE_DATA_DIRS = [
+    resolve(SRC_DIR, "..", "data", "datasets"),
+    resolve(SRC_DIR, "..", "..", "data", "datasets")
+];
+function findDir() {
+    for (const d of CANDIDATE_DATA_DIRS) {
+        if (existsSync(d))
+            return d;
+    }
+    return null;
+}
+function load(filename) {
+    const dir = findDir();
+    if (!dir)
+        return null;
+    const path = resolve(dir, filename);
+    if (!existsSync(path))
+        return null;
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+// ---- Caches ----
+let schoolsCache = null;
+let provincesCache = null;
+export function loadSchoolsAdapters() {
+    if (schoolsCache)
+        return schoolsCache;
+    const data = load("schools-adapters-2024.json");
+    if (!data)
+        throw new Error("schools-adapters-2024.json not found in cli/data/datasets/");
+    schoolsCache = data;
+    return data;
+}
+export function loadProvincesSpecialty() {
+    if (provincesCache)
+        return provincesCache;
+    const data = load("provinces-specialty-2024.json");
+    if (!data)
+        throw new Error("provinces-specialty-2024.json not found in cli/data/datasets/");
+    provincesCache = data;
+    return data;
+}
+// ---- Queries ----
+export function findSchoolAdapter(query) {
+    const file = loadSchoolsAdapters();
+    const q = query.trim();
+    // try zs_code exact match first
+    const byCode = file.schools.find((s) => s.zs_code === q);
+    if (byCode)
+        return byCode;
+    // then by name substring (case-insensitive on Chinese)
+    return file.schools.find((s) => s.name.includes(q)) ?? null;
+}
+export function listSchoolsOfferingProgram(program) {
+    const file = loadSchoolsAdapters();
+    return file.schools.filter((s) => {
+        const v = s.programs[program];
+        if (typeof v === "boolean")
+            return v === true;
+        if (v && typeof v === "object" && "offers" in v)
+            return v.offers === true;
+        return false;
+    });
+}
+export function findProvinceSpecialty(provinceKey) {
+    const file = loadProvincesSpecialty();
+    return file.provinces.find((p) => p.province === provinceKey) ?? null;
+}
+export function listProvinceKeys() {
+    return loadProvincesSpecialty().provinces.map((p) => p.province);
+}
+export function getCrossProvincePrograms() {
+    return loadProvincesSpecialty().cross_province_special_programs;
+}

package/dist/find.d.ts

@@ -0,0 +1,48 @@
+import { type IndexFilter } from "./index-loader.js";
+import { type ProvinceId } from "./codes.js";
+export type FindInput = {
+    keyword: string;
+    provinceId: ProvinceId;
+    year: number;
+    filter?: IndexFilter;
+    limit?: number;
+    concurrency?: number;
+};
+export type FindHit = {
+    schoolId: number;
+    zsCode: string;
+    schoolName: string;
+    schoolCity: string;
+    is985: boolean;
+    is211: boolean;
+    dualClass: string;
+    spcode: string;
+    spname: string;
+    sp_name: string;
+    num: number;
+    tuition: string;
+    length: string;
+    batch: string;
+    track: string;
+    xuanke: {
+        first: string | null;
+        reselect: string | null;
+        raw: string | null;
+    };
+    category: string;
+    info: string | null;
+};
+export type FindOutput = {
+    query: {
+        keyword: string;
+        province: {
+            id: ProvinceId;
+            name: string;
+        };
+        year: number;
+        filter?: IndexFilter;
+    };
+    schoolsScanned: number;
+    hits: FindHit[];
+};
+export declare function find(input: FindInput): Promise<FindOutput>;

package/dist/find.js

@@ -0,0 +1,87 @@
+// find — search for a major keyword across schools in a province for a given year.
+// Concurrent fetches against schoolspecialplan endpoint.
+import { loadIndex, filterIndex } from "./index-loader.js";
+import { getAdmissionPlan } from "./gaokao-cn.js";
+import { PROVINCES, TRACK_NAMES } from "./codes.js";
+function matchItem(item, keyword) {
+    const k = keyword.toLowerCase();
+    return (item.sp_name?.toLowerCase().includes(k) ||
+        item.spname?.toLowerCase().includes(k) ||
+        item.level3_name?.toLowerCase().includes(k) ||
+        item.spcode?.toLowerCase().includes(k) ||
+        false);
+}
+function toHit(row, item) {
+    return {
+        schoolId: row.gaokao_cn_id,
+        zsCode: row.zs_code,
+        schoolName: row.name,
+        schoolCity: row.city,
+        is985: row.f985,
+        is211: row.f211,
+        dualClass: row.dual_class,
+        spcode: item.spcode,
+        spname: item.spname,
+        sp_name: item.sp_name,
+        num: item.num,
+        tuition: item.tuition,
+        length: item.length,
+        batch: item.local_batch_name,
+        track: TRACK_NAMES[item.type] ?? item.type,
+        xuanke: {
+            first: item.sp_fxk || item.sg_fxk || null,
+            reselect: item.sp_sxk || item.sg_sxk || null,
+            raw: item.sp_xuanke || item.sg_xuanke || null
+        },
+        category: `${item.level2_name} · ${item.level3_name}`,
+        info: item.info || item.remark || null
+    };
+}
+export async function find(input) {
+    const index = loadIndex();
+    let rows = index.rows;
+    if (input.filter) {
+        rows = filterIndex({ generated_at: index.generated_at, rows }, input.filter);
+    }
+    // Only consider schools known to recruit in the target province (have pro_type_min entry).
+    rows = rows.filter((r) => Array.isArray(r.pro_type_min?.[String(input.provinceId)]));
+    const concurrency = input.concurrency ?? 12;
+    const hits = [];
+    let cursor = 0;
+    const workers = Array.from({ length: concurrency }, async () => {
+        while (cursor < rows.length) {
+            const row = rows[cursor++];
+            if (!row)
+                break;
+            try {
+                const plan = await getAdmissionPlan(row.gaokao_cn_id, input.year, input.provinceId);
+                for (const item of plan) {
+                    if (matchItem(item, input.keyword))
+                        hits.push(toHit(row, item));
+                }
+            }
+            catch {
+                // skip on error
+            }
+        }
+    });
+    await Promise.all(workers);
+    hits.sort((a, b) => {
+        // Prefer 985 > 211 > 双一流 > rest, then by plan count desc.
+        const ra = (a.is985 ? 3 : 0) + (a.is211 ? 2 : 0) + (a.dualClass === "双一流" ? 1 : 0);
+        const rb = (b.is985 ? 3 : 0) + (b.is211 ? 2 : 0) + (b.dualClass === "双一流" ? 1 : 0);
+        if (ra !== rb)
+            return rb - ra;
+        return b.num - a.num;
+    });
+    return {
+        query: {
+            keyword: input.keyword,
+            province: { id: input.provinceId, name: PROVINCES[input.provinceId].name },
+            year: input.year,
+            filter: input.filter
+        },
+        schoolsScanned: rows.length,
+        hits: input.limit ? hits.slice(0, input.limit) : hits
+    };
+}

package/dist/format.d.ts

@@ -0,0 +1,17 @@
+import type { RecommendOutput } from "./recommend.js";
+export declare function isTty(): boolean;
+export declare function renderTable(rows: string[][], opts?: {
+    gap?: number;
+}): string;
+export declare function formatRecommend(out: RecommendOutput, opts?: {
+    explain?: boolean;
+}): string;
+export declare function formatTop(rows: Array<{
+    schoolName: string;
+    baselineMinScore: number;
+    delta: number;
+    baselineYear: number;
+    city: string;
+    tags: string;
+    belong: string;
+}>): string;