gaokao-pro 0.1.0

package/dist/format.js

@@ -0,0 +1,109 @@
+export function isTty() {
+    return Boolean(process.stdout.isTTY);
+}
+function pad(s, w) {
+    // 中文 char ≈ 2 columns, ASCII ≈ 1. Width-aware padding.
+    let used = 0;
+    for (const ch of s) {
+        used += ch.charCodeAt(0) > 127 ? 2 : 1;
+    }
+    return s + " ".repeat(Math.max(0, w - used));
+}
+function colW(rows, col) {
+    let w = 0;
+    for (const r of rows) {
+        const cell = r[col] ?? "";
+        let used = 0;
+        for (const ch of cell)
+            used += ch.charCodeAt(0) > 127 ? 2 : 1;
+        if (used > w)
+            w = used;
+    }
+    return w;
+}
+export function renderTable(rows, opts = {}) {
+    const gap = opts.gap ?? 2;
+    if (rows.length === 0)
+        return "(empty)";
+    const cols = Math.max(...rows.map((r) => r.length));
+    const widths = Array.from({ length: cols }, (_, c) => colW(rows, c));
+    const sep = " ".repeat(gap);
+    return rows
+        .map((r) => r.map((cell, i) => (i === cols - 1 ? cell ?? "" : pad(cell ?? "", widths[i]))).join(sep))
+        .join("\n");
+}
+function labelTags(c) {
+    const tags = [];
+    if (c.is985)
+        tags.push("985");
+    if (c.is211 && !c.is985)
+        tags.push("211");
+    if (c.dualClass === "双一流" && !c.is985 && !c.is211)
+        tags.push("双一流");
+    return tags.join(" ");
+}
+export function formatRecommend(out, opts = {}) {
+    const lines = [];
+    const q = out.query;
+    lines.push(`gaokao-pro recommend  score=${q.score}  ${q.province.name}(${q.province.reform})  ` +
+        `subjects=${q.subjects.join("/")}  track=${q.trackName}  ` +
+        (q.rank !== undefined ? `rank=${q.rank}  ` : "") +
+        `evaluated=${out.evaluated}  skipped=${out.buckets.skipped}`);
+    const order = [
+        { key: "冲", label: "冲  REACH" },
+        { key: "稳", label: "稳  MATCH" },
+        { key: "保", label: "保  SAFETY" },
+        { key: "out", label: "—  out of range" }
+    ];
+    for (const { key, label } of order) {
+        const items = out.buckets[key];
+        if (items.length === 0)
+            continue;
+        lines.push("");
+        lines.push(`[${label}]  ${items.length} school${items.length === 1 ? "" : "s"}`);
+        const rows = [
+            ["  school", "delta", `min(${items[0]?.baselineYear ?? "—"})`, "city", "tags", "belong"]
+        ];
+        for (const c of items) {
+            rows.push([
+                `  ${c.name}`,
+                (c.delta >= 0 ? "+" : "") + c.delta,
+                String(c.baselineMinScore),
+                c.city,
+                labelTags(c),
+                c.belong
+            ]);
+        }
+        lines.push(renderTable(rows));
+        if (opts.explain) {
+            for (const c of items.slice(0, 3)) {
+                const reason = key === "冲"
+                    ? `差 ${Math.abs(c.delta)} 分（基线 ${c.baselineMinScore}，${c.baselineYear} ${c.baselineTrackName}）— 有希望但需要更高发挥`
+                    : key === "稳"
+                        ? `贴近基线 ${c.baselineMinScore}（${c.baselineYear} ${c.baselineTrackName}），同分段稳妥选择`
+                        : key === "保"
+                            ? `高于基线 ${c.delta} 分，作为兜底足够稳`
+                            : `分差 ${c.delta} 超出 ±25 分窗口，不建议`;
+                lines.push(`    · ${c.name}: ${reason}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+export function formatTop(rows) {
+    const out = [
+        ["  rank", "school", "delta", "min(year)", "city", "tags", "belong"]
+    ];
+    rows.forEach((r, i) => {
+        out.push([
+            `  ${String(i + 1).padStart(2)}`,
+            r.schoolName,
+            (r.delta >= 0 ? "+" : "") + r.delta,
+            `${r.baselineMinScore} (${r.baselineYear})`,
+            r.city,
+            r.tags,
+            r.belong
+        ]);
+    });
+    return renderTable(out);
+}

package/dist/gaokao-cn.d.ts

@@ -0,0 +1,122 @@
+export type SchoolInfo = {
+    school_id: string;
+    name: string;
+    zs_code: string;
+    belong: string;
+    province_name: string;
+    city_name: string;
+    town_name: string;
+    level_name: string;
+    type_name: string;
+    nature_name: string;
+    dual_class_name: string;
+    f985: string;
+    f211: string;
+    rank: Record<string, string>;
+    xueke_rank: Record<string, string>;
+    xueke_pinggu?: Record<string, string>;
+    pro_type_min: Record<string, Array<{
+        year: number;
+        type: Record<string, string>;
+    }>>;
+    province_score_year: string;
+    content: string;
+    site: string;
+    phone: string;
+    address: string;
+};
+export type AdmissionPlanItem = {
+    school_id: string;
+    special_id: string;
+    province: string;
+    year?: string;
+    type: string;
+    zslx: string;
+    zslx_name: string;
+    batch: string;
+    local_batch_name: string;
+    num: number;
+    length: string;
+    tuition: string;
+    spcode: string;
+    spname: string;
+    sp_name: string;
+    info: string;
+    remark: string;
+    level1_name: string;
+    level2_name: string;
+    level3_name: string;
+    special_group: string;
+    sp_xuanke: string;
+    sp_fxk: string;
+    sp_sxk: string;
+    sp_info: string;
+    sg_xuanke: string;
+    sg_fxk: string;
+    sg_sxk: string;
+    sg_info: string;
+    sg_name: string;
+    first_km: string;
+};
+export type AdmissionPlanResponse = {
+    [bucket: string]: {
+        numFound: number;
+        item: AdmissionPlanItem[];
+    };
+};
+export type AdmissionScoreItem = {
+    school_id: string;
+    special_id: string;
+    province: string;
+    type: string;
+    zslx: string;
+    zslx_name: string;
+    batch: string;
+    local_batch_name: string;
+    spcode?: string;
+    spname: string;
+    sp_name: string;
+    info: string;
+    remark: string;
+    level1_name: string;
+    level2_name: string;
+    level3_name: string;
+    special_group: string;
+    max: number;
+    min: number;
+    average: number;
+    lq_num: string;
+    min_section: string;
+    min_range: string;
+    min_rank_range: string;
+    range_max_rank: string;
+    is_score_range: string;
+    diff: number;
+    first_km: string;
+    sp_type: string;
+    sp_fxk: string;
+    sp_sxk: string;
+    sp_info: string;
+    sp_xuanke: string;
+    sg_fxk: string;
+    sg_sxk: string;
+    sg_type: string;
+    sg_name: string;
+    sg_info: string;
+    sg_xuanke: string;
+};
+export type AdmissionScoreResponse = {
+    [bucket: string]: {
+        numFound: number;
+        item: AdmissionScoreItem[];
+    };
+};
+export declare function getSchoolInfo(schoolId: number | string): Promise<SchoolInfo>;
+export declare function getAdmissionPlan(schoolId: number | string, year: number, provinceId: number | string): Promise<AdmissionPlanItem[]>;
+export declare function getAdmissionScores(schoolId: number | string, year: number, provinceId: number | string): Promise<AdmissionScoreItem[]>;
+export declare function extractHistoricalScores(info: SchoolInfo, provinceId: number | string): Array<{
+    year: number;
+    track: string;
+    trackName: string;
+    minScore: number;
+}>;

package/dist/gaokao-cn.js

@@ -0,0 +1,49 @@
+// Client for static-data.gaokao.cn — the 中国教育在线 "掌上高考" static JSON tier.
+// No auth, no sign, no rate limit observed. Treat it like a public CDN.
+const BASE = "https://static-data.gaokao.cn/www/2.0";
+const UA = "gaokao-pro/0.0.1 (+https://github.com/HA7CH/gaokao-pro)";
+async function fetchJson(path) {
+    const url = `${BASE}${path}`;
+    const res = await fetch(url, { headers: { "User-Agent": UA } });
+    if (!res.ok) {
+        throw new Error(`gaokao.cn ${res.status} ${res.statusText} for ${url}`);
+    }
+    const body = (await res.json());
+    if (body.code !== "0000") {
+        throw new Error(`gaokao.cn returned code=${body.code} message=${body.message} for ${url}`);
+    }
+    return body.data;
+}
+// ---- Client ----
+export async function getSchoolInfo(schoolId) {
+    return fetchJson(`/school/${schoolId}/info.json`);
+}
+export async function getAdmissionPlan(schoolId, year, provinceId) {
+    const raw = await fetchJson(`/schoolspecialplan/${schoolId}/${year}/${provinceId}.json`);
+    // Flatten all buckets into a single array.
+    return Object.values(raw).flatMap((bucket) => bucket?.item ?? []);
+}
+export async function getAdmissionScores(schoolId, year, provinceId) {
+    const raw = await fetchJson(`/schoolspecialscore/${schoolId}/${year}/${provinceId}.json`);
+    return Object.values(raw).flatMap((bucket) => bucket?.item ?? []);
+}
+// Convenience: historical min-score series for a given (school, province).
+// Returns [{ year, track, minScore }] sorted by year descending.
+export function extractHistoricalScores(info, provinceId) {
+    const entries = info.pro_type_min?.[String(provinceId)] ?? [];
+    const out = [];
+    for (const e of entries) {
+        for (const [track, score] of Object.entries(e.type ?? {})) {
+            const min = Number(score);
+            if (Number.isFinite(min) && min > 0) {
+                out.push({
+                    year: e.year,
+                    track,
+                    trackName: track,
+                    minScore: min
+                });
+            }
+        }
+    }
+    return out.sort((a, b) => b.year - a.year || a.track.localeCompare(b.track));
+}

package/dist/index-loader.d.ts

@@ -0,0 +1,33 @@
+export type SchoolRow = {
+    gaokao_cn_id: number;
+    zs_code: string;
+    name: string;
+    province: string;
+    city: string;
+    level: string;
+    type: string;
+    nature: string;
+    belong: string;
+    f985: boolean;
+    f211: boolean;
+    dual_class: string;
+    pro_type_min: Record<string, Array<{
+        year: number;
+        type: Record<string, string>;
+    }>>;
+};
+export type SchoolIndex = {
+    generated_at: string;
+    rows: SchoolRow[];
+};
+export declare function loadIndex(): SchoolIndex;
+export type IndexFilter = {
+    level?: string;
+    type?: string;
+    nature?: string;
+    belong?: string;
+    f985?: boolean;
+    f211?: boolean;
+    dualClass?: boolean;
+};
+export declare function filterIndex(index: SchoolIndex, f: IndexFilter): SchoolRow[];

package/dist/index-loader.js

@@ -0,0 +1,59 @@
+// Loads cli/data/school-index.json.gz — the local school corpus built by `probe`.
+// Exposes filters by province / labels / level / type / belong.
+import { readFileSync, existsSync } from "node:fs";
+import { gunzipSync } from "node:zlib";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const SRC_DIR = dirname(__filename);
+// Look for the gzipped index first (npm-shipped), then the legacy uncompressed
+// docs path (dev convenience).
+const CANDIDATE_PATHS = [
+    // From src/ via tsx: cli/src/ → cli/data/
+    resolve(SRC_DIR, "..", "data", "school-index.json.gz"),
+    // From dist/ compiled: cli/dist/ → cli/data/
+    resolve(SRC_DIR, "..", "..", "data", "school-index.json.gz"),
+    // Legacy uncompressed paths
+    resolve(SRC_DIR, "..", "..", "docs", "school-index.json"),
+    resolve(SRC_DIR, "..", "..", "..", "docs", "school-index.json")
+];
+let cached = null;
+export function loadIndex() {
+    if (cached)
+        return cached;
+    let lastErr = null;
+    for (const path of CANDIDATE_PATHS) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const buf = readFileSync(path);
+            const raw = path.endsWith(".gz") ? gunzipSync(buf).toString("utf8") : buf.toString("utf8");
+            cached = JSON.parse(raw);
+            return cached;
+        }
+        catch (e) {
+            lastErr = e;
+        }
+    }
+    throw new Error(`school-index not found in any of: ${CANDIDATE_PATHS.join(", ")}. ` +
+        `Run \`pnpm probe\` to build it. Last error: ${lastErr}`);
+}
+export function filterIndex(index, f) {
+    return index.rows.filter((r) => {
+        if (f.level !== undefined && r.level !== f.level)
+            return false;
+        if (f.type !== undefined && r.type !== f.type)
+            return false;
+        if (f.nature !== undefined && r.nature !== f.nature)
+            return false;
+        if (f.belong !== undefined && r.belong !== f.belong)
+            return false;
+        if (f.f985 === true && !r.f985)
+            return false;
+        if (f.f211 === true && !r.f211)
+            return false;
+        if (f.dualClass === true && r.dual_class !== "双一流")
+            return false;
+        return true;
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};