@reconcrap/boss-recommend-mcp 0.1.0 → 0.1.1

package/README.md

@@ -20,6 +20,8 @@ MCP 工具名：`run_recommend_pipeline`
 
 - 页面目标固定为 `https://www.zhipin.com/web/chat/recommend`
 - 支持推荐页原生筛选：学校标签 / 性别 / 近14天没有
+- 支持推荐页原生筛选：学校标签 / 学历 / 性别 / 近14天没有
+- 学历支持单选与多选语义：如“本科及以上”会展开为 `本科/硕士/博士`；如“大专、本科”只勾选这两项
 - `post_action` 必须在每次完整运行开始时确认一次
 - `target_count` 会在每次运行开始时询问一次（可留空，不设上限）
 - 当 `post_action=greet` 时，必须在运行开始时确认 `max_greet_count`
@@ -102,6 +104,7 @@ node src/cli.js run --instruction-file request.txt --confirmation-file confirmat
   },
   "overrides": {
     "school_tag": "211",
+    "degree": ["本科", "硕士", "博士"],
     "gender": "女",
     "recent_not_view": "近14天没有",
     "criteria": "候选人需要有 AI Agent 或 MCP 工具开发经验",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",

package/skills/boss-recommend-pipeline/SKILL.md

@@ -50,6 +50,7 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
     - `max_greet_count_value` (integer)
   - `overrides`
     - `school_tag`
+    - `degree`（可传单值或数组；如“本科及以上”应展开为 `["本科","硕士","博士"]`）
     - `gender`
     - `recent_not_view`
     - `criteria`

package/src/adapters.js

@@ -36,6 +36,15 @@ function parsePositiveInteger(raw) {
   return Number.isFinite(value) && value > 0 ? value : null;
 }
 
+function serializeDegreeSelection(value) {
+  if (Array.isArray(value)) {
+    const normalized = value.map((item) => String(item || "").trim()).filter(Boolean);
+    return normalized.length ? normalized.join(",") : "不限";
+  }
+  const normalized = String(value || "").trim();
+  return normalized || "不限";
+}
+
 function resolveScreenConfigPath(workspaceRoot) {
   const envConfigPath = process.env.BOSS_RECOMMEND_SCREEN_CONFIG
     ? path.resolve(process.env.BOSS_RECOMMEND_SCREEN_CONFIG)
@@ -506,6 +515,8 @@ export async function runRecommendSearchCli({ workspaceRoot, searchParams }) {
     cliPath,
     "--school-tag",
     searchParams.school_tag,
+    "--degree",
+    serializeDegreeSelection(searchParams.degree),
     "--gender",
     searchParams.gender,
     "--recent-not-view",

package/src/index.js

@@ -64,6 +64,23 @@ function createToolSchema() {
               type: "string",
               enum: ["不限", "985", "211", "双一流院校", "留学", "国内外名校", "公办本科"]
             },
+            degree: {
+              oneOf: [
+                {
+                  type: "string",
+                  enum: ["不限", "初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"]
+                },
+                {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    enum: ["不限", "初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"]
+                  },
+                  minItems: 1,
+                  uniqueItems: true
+                }
+              ]
+            },
             gender: {
               type: "string",
               enum: ["不限", "男", "女"]

package/src/parser.js

@@ -7,6 +7,25 @@ const SCHOOL_TAG_OPTIONS = [
   "国内外名校",
   "公办本科"
 ];
+const DEGREE_OPTIONS = [
+  "不限",
+  "初中及以下",
+  "中专/中技",
+  "高中",
+  "大专",
+  "本科",
+  "硕士",
+  "博士"
+];
+const DEGREE_ORDER = [
+  "初中及以下",
+  "中专/中技",
+  "高中",
+  "大专",
+  "本科",
+  "硕士",
+  "博士"
+];
 const GENDER_OPTIONS = ["不限", "男", "女"];
 const RECENT_NOT_VIEW_OPTIONS = ["不限", "近14天没有"];
 const POST_ACTION_OPTIONS = ["favorite", "greet"];
@@ -30,6 +49,15 @@ const SCHOOL_TAG_PATTERNS = [
   { label: "国内外名校", pattern: /国内外名校|名校/i },
   { label: "公办本科", pattern: /公办本科/i }
 ];
+const DEGREE_PATTERNS = [
+  { label: "初中及以下", pattern: /初中及以下|初中以下/i },
+  { label: "中专/中技", pattern: /中专\s*\/\s*中技|中专中技|中专|中技/i },
+  { label: "高中", pattern: /(?:学历|教育|要求)?[^。；;\n]{0,8}高中/i },
+  { label: "大专", pattern: /(?:学历|教育|要求)?[^。；;\n]{0,8}(?:大专|专科)/i },
+  { label: "本科", pattern: /(?:学历|教育|要求)?[^。；;\n]{0,8}(?:本科|学士)/i },
+  { label: "硕士", pattern: /(?:学历|教育|要求)?[^。；;\n]{0,8}(?:硕士|研究生)/i },
+  { label: "博士", pattern: /(?:学历|教育|要求)?[^。；;\n]{0,8}博士/i }
+];
 const GENDER_PATTERNS = [
   { label: "男", pattern: /(?:性别|候选人|人选)?[^。；;\n]{0,8}(?:男生|男性|男)/i },
   { label: "女", pattern: /(?:性别|候选人|人选)?[^。；;\n]{0,8}(?:女生|女性|女)/i }
@@ -57,6 +85,7 @@ const MAX_GREET_COUNT_PATTERNS = [
 ];
 const FILTER_CLAUSE_PATTERNS = [
   /学校标签|院校标签|985|211|双一流|留学|国内外名校|公办本科/i,
+  /学历|学位|教育|初中及以下|中专|中技|高中|大专|专科|本科|硕士|研究生|博士/i,
   /性别|男生|女生|男性|女性|男\b|女\b/i,
   /近?14天(?:内)?没有|近?14天(?:内)?没看过|近?14天(?:内)?未查看|过滤[^。；;\n]{0,12}14天|排除[^。；;\n]{0,12}14天/i,
   /目标(?:处理|筛选)?(?:人数|数量)?|至少(?:处理|筛选)|(?:处理|筛选)\s*\d+\s*(?:位|人)/i,
@@ -89,6 +118,75 @@ function normalizeSchoolTag(value) {
   return null;
 }
 
+function normalizeDegree(value) {
+  const normalized = normalizeText(value);
+  if (!normalized) return null;
+  if (normalized === "专科") return "大专";
+  if (normalized === "研究生") return "硕士";
+  if (normalized === "中专" || normalized === "中技" || normalized === "中专中技") return "中专/中技";
+  return DEGREE_OPTIONS.includes(normalized) ? normalized : null;
+}
+
+function sortDegreeSelections(values) {
+  return uniqueList(values).sort((left, right) => {
+    const leftIndex = DEGREE_ORDER.indexOf(left);
+    const rightIndex = DEGREE_ORDER.indexOf(right);
+    return leftIndex - rightIndex;
+  });
+}
+
+function expandDegreeAtOrAbove(value) {
+  const normalized = normalizeDegree(value);
+  if (!normalized || normalized === "不限") return [];
+  const startIndex = DEGREE_ORDER.indexOf(normalized);
+  if (startIndex === -1) return [];
+  return DEGREE_ORDER.slice(startIndex);
+}
+
+function parseDegreeSelectionsFromText(text) {
+  const normalizedText = normalizeText(text);
+  if (!normalizedText) return [];
+  if (/(?:学历|学位|教育)[^。；;\n]{0,6}不限|不限[^。；;\n]{0,6}(?:学历|学位|教育)/i.test(normalizedText)) {
+    return ["不限"];
+  }
+
+  const selected = [];
+  const atOrAbovePattern = /(初中及以下|中专\/中技|中专中技|中专|中技|高中|大专|专科|本科|硕士|研究生|博士)\s*(?:及|或)?以上/g;
+  let match;
+  while ((match = atOrAbovePattern.exec(normalizedText)) !== null) {
+    selected.push(...expandDegreeAtOrAbove(match[1]));
+  }
+
+  for (const { label, pattern } of DEGREE_PATTERNS) {
+    if (pattern.test(normalizedText)) {
+      selected.push(label);
+    }
+  }
+  return sortDegreeSelections(selected);
+}
+
+function normalizeDegreeSelections(input) {
+  if (Array.isArray(input)) {
+    const normalized = sortDegreeSelections(input.map((item) => normalizeDegree(item)).filter(Boolean));
+    if (!normalized.length) return null;
+    return normalized.includes("不限") ? ["不限"] : normalized;
+  }
+
+  const text = normalizeText(input);
+  if (!text) return null;
+  if (text.includes("以上")) {
+    const fromText = parseDegreeSelectionsFromText(text);
+    if (fromText.length) return fromText;
+  }
+  const parts = text.split(/[，,、/|]/).map((item) => normalizeDegree(item)).filter(Boolean);
+  if (parts.length) {
+    const normalized = sortDegreeSelections(parts);
+    return normalized.includes("不限") ? ["不限"] : normalized;
+  }
+  const single = normalizeDegree(text);
+  return single ? [single] : null;
+}
+
 function normalizeGender(value) {
   const normalized = normalizeText(value);
   if (!normalized) return null;
@@ -142,6 +240,10 @@ function extractGender(text) {
   return null;
 }
 
+function extractDegrees(text) {
+  return parseDegreeSelectionsFromText(text);
+}
+
 function extractRecentNotView(text) {
   for (const pattern of RECENT_NOT_VIEW_NEGATIVE_PATTERNS) {
     if (pattern.test(text)) {
@@ -298,13 +400,22 @@ function collectSuspiciousFields({ detectedSchoolTags }) {
 export function parseRecommendInstruction({ instruction, confirmation, overrides }) {
   const text = normalizeText(instruction);
   const detectedSchoolTags = extractSchoolTags(text);
+  const detectedDegrees = extractDegrees(text);
   const overrideSchoolTag = normalizeSchoolTag(overrides?.school_tag);
+  const overrideDegrees = normalizeDegreeSelections(overrides?.degree);
   const overrideGender = normalizeGender(overrides?.gender);
   const overrideRecentNotView = normalizeRecentNotView(overrides?.recent_not_view);
   const overrideCriteria = overrides?.criteria;
 
   const searchParams = {
     school_tag: overrideSchoolTag || detectedSchoolTags[0] || "不限",
+    degree: (
+      (Array.isArray(overrideDegrees) && overrideDegrees.length > 0
+        ? overrideDegrees
+        : Array.isArray(detectedDegrees) && detectedDegrees.length > 0
+          ? detectedDegrees
+          : ["不限"])
+    ),
     gender: overrideGender || extractGender(text) || "不限",
     recent_not_view: overrideRecentNotView || extractRecentNotView(text) || "不限"
   };
@@ -415,6 +526,7 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
 }
 
 export {
+  DEGREE_OPTIONS,
   GENDER_OPTIONS,
   POST_ACTION_LABELS,
   POST_ACTION_OPTIONS,

package/src/test-parser.js

@@ -9,6 +9,7 @@ function testNeedConfirmationIncludesPostAction() {
   });
 
   assert.equal(result.searchParams.school_tag, "985");
+  assert.deepEqual(result.searchParams.degree, ["不限"]);
   assert.equal(result.searchParams.gender, "男");
   assert.equal(result.searchParams.recent_not_view, "近14天没有");
   assert.equal(result.screenParams.criteria, "有大模型平台经验");
@@ -33,12 +34,14 @@ function testConfirmedPostActionAndOverrides() {
     },
     overrides: {
       school_tag: "211",
+      degree: "本科",
       recent_not_view: "近14天没有",
       target_count: 12
     }
   });
 
   assert.equal(result.searchParams.school_tag, "211");
+  assert.deepEqual(result.searchParams.degree, ["本科"]);
   assert.equal(result.searchParams.gender, "女");
   assert.equal(result.searchParams.recent_not_view, "近14天没有");
   assert.equal(result.screenParams.criteria, "有多模态经历");
@@ -65,10 +68,53 @@ function testMultipleSchoolTagsMarkedSuspicious() {
   });
 
   assert.equal(result.searchParams.school_tag, "985");
+  assert.deepEqual(result.searchParams.degree, ["不限"]);
   assert.equal(result.suspicious_fields.length, 1);
   assert.equal(result.suspicious_fields[0].field, "school_tag");
 }
 
+function testDegreeCanBeExtracted() {
+  const result = parseRecommendInstruction({
+    instruction: "推荐页筛选本科女生，近14天没有，有大模型项目经验",
+    confirmation: null,
+    overrides: null
+  });
+
+  assert.deepEqual(result.searchParams.degree, ["本科"]);
+}
+
+function testDegreeAtOrAboveExpansion() {
+  const result = parseRecommendInstruction({
+    instruction: "推荐页筛选大专及以上，近14天没有，有Agent经验",
+    confirmation: null,
+    overrides: null
+  });
+
+  assert.deepEqual(result.searchParams.degree, ["大专", "本科", "硕士", "博士"]);
+}
+
+function testDegreeExplicitListOnly() {
+  const result = parseRecommendInstruction({
+    instruction: "推荐页筛选大专、本科，近14天没有，有Agent经验",
+    confirmation: null,
+    overrides: null
+  });
+
+  assert.deepEqual(result.searchParams.degree, ["大专", "本科"]);
+}
+
+function testDegreeOverrideCanBeArray() {
+  const result = parseRecommendInstruction({
+    instruction: "推荐页筛选本科，近14天没有，有Agent经验",
+    confirmation: null,
+    overrides: {
+      degree: ["大专", "本科"]
+    }
+  });
+
+  assert.deepEqual(result.searchParams.degree, ["大专", "本科"]);
+}
+
 function testCriteriaCanBeProvidedViaOverrides() {
   const result = parseRecommendInstruction({
     instruction: "推荐页筛选211女生",
@@ -190,6 +236,10 @@ function main() {
   testNeedConfirmationIncludesPostAction();
   testConfirmedPostActionAndOverrides();
   testMultipleSchoolTagsMarkedSuspicious();
+  testDegreeCanBeExtracted();
+  testDegreeAtOrAboveExpansion();
+  testDegreeExplicitListOnly();
+  testDegreeOverrideCanBeArray();
   testCriteriaCanBeProvidedViaOverrides();
   testMissingCriteriaTriggersNeedInput();
   testMcpMentionShouldStayInCriteria();

package/src/test-pipeline.js

@@ -5,6 +5,7 @@ function createParsed(overrides = {}) {
   return {
     searchParams: {
       school_tag: "985",
+      degree: ["本科"],
       gender: "男",
       recent_not_view: "近14天没有"
     },
@@ -180,6 +181,7 @@ async function testCompletedPipeline() {
   assert.equal(result.result.processed_count, 10);
   assert.equal(result.result.passed_count, 3);
   assert.equal(result.result.post_action, "favorite");
+  assert.deepEqual(result.result.applied_filters.degree, ["本科"]);
   assert.equal(calls[0].type, "search");
   assert.equal(calls[1].type, "screen");
 }

package/vendor/boss-recommend-screen-cli/boss-recommend-screen-cli.cjs

@@ -53,7 +53,18 @@ function parseArgs(argv) {
     output: path.resolve(process.cwd(), `筛选结果_${Date.now()}.csv`),
     postAction: null,
     postActionConfirmed: null,
-    help: false
+    help: false,
+    __provided: {
+      baseUrl: false,
+      apiKey: false,
+      model: false,
+      criteria: false,
+      targetCount: false,
+      maxGreetCount: false,
+      port: false,
+      postAction: false,
+      postActionConfirmed: false
+    }
   };
 
   for (let index = 0; index < argv.length; index += 1) {
@@ -61,12 +72,15 @@ function parseArgs(argv) {
     const next = argv[index + 1];
     if (token === "--baseurl" && next) {
       parsed.baseUrl = next;
+      parsed.__provided.baseUrl = true;
       index += 1;
     } else if (token === "--apikey" && next) {
       parsed.apiKey = next;
+      parsed.__provided.apiKey = true;
       index += 1;
     } else if (token === "--model" && next) {
       parsed.model = next;
+      parsed.__provided.model = true;
       index += 1;
     } else if (token === "--openai-organization" && next) {
       parsed.openaiOrganization = next;
@@ -76,24 +90,30 @@ function parseArgs(argv) {
       index += 1;
     } else if (token === "--criteria" && next) {
       parsed.criteria = next;
+      parsed.__provided.criteria = true;
       index += 1;
     } else if (token === "--targetCount" && next) {
       parsed.targetCount = parsePositiveInteger(next);
+      parsed.__provided.targetCount = true;
       index += 1;
     } else if (token === "--max-greet-count" && next) {
       parsed.maxGreetCount = parsePositiveInteger(next);
+      parsed.__provided.maxGreetCount = true;
       index += 1;
     } else if (token === "--port" && next) {
       parsed.port = parsePositiveInteger(next) || DEFAULT_PORT;
+      parsed.__provided.port = true;
       index += 1;
     } else if (token === "--output" && next) {
       parsed.output = path.resolve(next);
       index += 1;
     } else if (token === "--post-action" && next) {
       parsed.postAction = normalizePostAction(next);
+      parsed.__provided.postAction = true;
       index += 1;
     } else if (token === "--post-action-confirmed" && next) {
       parsed.postActionConfirmed = parseBoolean(next);
+      parsed.__provided.postActionConfirmed = true;
       index += 1;
     } else if (token === "--help" || token === "-h") {
       parsed.help = true;
@@ -103,6 +123,109 @@ function parseArgs(argv) {
   return parsed;
 }
 
+function isInteractiveTTY() {
+  return Boolean(process.stdin?.isTTY && process.stdout?.isTTY);
+}
+
+async function askWithValidation(ask, question, validate, options = {}) {
+  const { allowEmpty = false, defaultValue = undefined } = options;
+  while (true) {
+    const answer = normalizeText(await ask(question));
+    if (!answer) {
+      if (defaultValue !== undefined) return defaultValue;
+      if (allowEmpty) return null;
+    }
+    const validated = validate(answer);
+    if (validated !== null && validated !== undefined) return validated;
+    console.error("输入无效，请重试。");
+  }
+}
+
+async function promptMissingInputs(args) {
+  if (!isInteractiveTTY() || args.help) return args;
+
+  if (args.__provided.postAction && args.postAction && args.postActionConfirmed === null) {
+    args.postActionConfirmed = true;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (question) => new Promise((resolve) => rl.question(question, resolve));
+  try {
+    if (!normalizeText(args.criteria)) {
+      args.criteria = await askWithValidation(
+        ask,
+        "请输入筛选标准（--criteria）: ",
+        (value) => normalizeText(value) || null
+      );
+    }
+    if (!normalizeText(args.baseUrl)) {
+      args.baseUrl = await askWithValidation(
+        ask,
+        "请输入模型接口 baseUrl（--baseurl，例如 https://api.openai.com/v1）: ",
+        (value) => normalizeText(value) || null
+      );
+    }
+    if (!normalizeText(args.apiKey)) {
+      args.apiKey = await askWithValidation(
+        ask,
+        "请输入模型接口 apiKey（--apikey）: ",
+        (value) => normalizeText(value) || null
+      );
+    }
+    if (!normalizeText(args.model)) {
+      args.model = await askWithValidation(
+        ask,
+        "请输入模型名（--model）: ",
+        (value) => normalizeText(value) || null
+      );
+    }
+    if (args.targetCount === null) {
+      const targetCount = await askWithValidation(
+        ask,
+        "请输入目标筛选人数（--targetCount，可留空表示不设上限）: ",
+        (value) => parsePositiveInteger(value),
+        { allowEmpty: true }
+      );
+      if (Number.isInteger(targetCount) && targetCount > 0) {
+        args.targetCount = targetCount;
+      }
+    }
+    if (!(args.postActionConfirmed === true && args.postAction)) {
+      args.postAction = await askWithValidation(
+        ask,
+        "本次通过人选统一执行什么动作？请输入 1(收藏) 或 2(直接沟通): ",
+        (value) => {
+          if (value === "1") return "favorite";
+          if (value === "2") return "greet";
+          return null;
+        }
+      );
+      args.postActionConfirmed = true;
+    }
+    if (args.postAction === "greet" && !(Number.isInteger(args.maxGreetCount) && args.maxGreetCount > 0)) {
+      args.maxGreetCount = await askWithValidation(
+        ask,
+        "本次最多打招呼多少位候选人？请输入正整数（--max-greet-count）: ",
+        (value) => parsePositiveInteger(value)
+      );
+    }
+    if (!args.__provided.port) {
+      args.port = await askWithValidation(
+        ask,
+        `Chrome 调试端口（--port，默认: ${args.port}）: `,
+        (value) => parsePositiveInteger(value),
+        { defaultValue: args.port }
+      );
+    }
+    return args;
+  } finally {
+    rl.close();
+  }
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1605,7 +1728,8 @@ async function main() {
     return;
   }
 
-  const cli = new RecommendScreenCli(args);
+  const finalArgs = await promptMissingInputs(args);
+  const cli = new RecommendScreenCli(finalArgs);
   const result = await cli.run();
   console.log(JSON.stringify(result));
 }

package/vendor/boss-recommend-search-cli/src/cli.js

@@ -1,22 +1,90 @@
 #!/usr/bin/env node
 import process from "node:process";
+import readline from "node:readline";
 import CDP from "chrome-remote-interface";
 
 const DEFAULT_PORT = 9222;
 const RECOMMEND_URL_FRAGMENT = "/web/chat/recommend";
+const SCHOOL_TAG_OPTIONS = ["不限", "985", "211", "双一流院校", "留学", "国内外名校", "公办本科"];
+const DEGREE_OPTIONS = ["不限", "初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"];
+const DEGREE_ORDER = ["初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"];
+const GENDER_OPTIONS = ["不限", "男", "女"];
+const RECENT_NOT_VIEW_OPTIONS = ["不限", "近14天没有"];
+
+function normalizeText(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
 
 function parsePositiveInteger(raw) {
   const value = Number.parseInt(String(raw || ""), 10);
   return Number.isFinite(value) && value > 0 ? value : null;
 }
 
+function normalizeDegree(value) {
+  const normalized = normalizeText(value);
+  if (!normalized) return null;
+  if (normalized === "专科") return "大专";
+  if (normalized === "研究生") return "硕士";
+  if (normalized === "中专" || normalized === "中技" || normalized === "中专中技") return "中专/中技";
+  return DEGREE_OPTIONS.includes(normalized) ? normalized : null;
+}
+
+function sortDegreeSelection(values) {
+  return Array.from(new Set(values.filter(Boolean))).sort((left, right) => DEGREE_ORDER.indexOf(left) - DEGREE_ORDER.indexOf(right));
+}
+
+function expandDegreeAtOrAbove(value) {
+  const normalized = normalizeDegree(value);
+  if (!normalized || normalized === "不限") return [];
+  const index = DEGREE_ORDER.indexOf(normalized);
+  if (index === -1) return [];
+  return DEGREE_ORDER.slice(index);
+}
+
+function parseDegreeSelection(raw) {
+  const text = normalizeText(raw);
+  if (!text) return null;
+  if (text === "不限") return ["不限"];
+  if (/不限/.test(text) && !/(初中|中专|中技|高中|大专|专科|本科|硕士|研究生|博士)/.test(text)) {
+    return ["不限"];
+  }
+
+  const selected = [];
+  const atOrAbovePattern = /(初中及以下|中专\/中技|中专中技|中专|中技|高中|大专|专科|本科|硕士|研究生|博士)\s*(?:及|或)?以上/g;
+  let match;
+  while ((match = atOrAbovePattern.exec(text)) !== null) {
+    selected.push(...expandDegreeAtOrAbove(match[1]));
+  }
+
+  const chunks = text.split(/[，,、/|]/).map((item) => normalizeDegree(item)).filter(Boolean);
+  selected.push(...chunks);
+
+  for (const label of DEGREE_OPTIONS) {
+    if (label === "不限") continue;
+    if (text.includes(label)) {
+      selected.push(label);
+    }
+  }
+
+  const normalized = sortDegreeSelection(selected);
+  return normalized.length ? normalized : null;
+}
+
 function parseArgs(argv) {
   const args = {
     schoolTag: "不限",
+    degree: ["不限"],
     gender: "不限",
     recentNotView: "不限",
     port: DEFAULT_PORT,
-    help: false
+    help: false,
+    __provided: {
+      schoolTag: false,
+      degree: false,
+      gender: false,
+      recentNotView: false,
+      port: false
+    }
   };
 
   for (let index = 0; index < argv.length; index += 1) {
@@ -24,15 +92,23 @@ function parseArgs(argv) {
     const next = argv[index + 1];
     if (token === "--school-tag" && next) {
       args.schoolTag = next;
+      args.__provided.schoolTag = true;
+      index += 1;
+    } else if (token === "--degree" && next) {
+      args.degree = parseDegreeSelection(next);
+      args.__provided.degree = true;
       index += 1;
     } else if (token === "--gender" && next) {
       args.gender = next;
+      args.__provided.gender = true;
       index += 1;
     } else if (token === "--recent-not-view" && next) {
       args.recentNotView = next;
+      args.__provided.recentNotView = true;
       index += 1;
     } else if (token === "--port" && next) {
       args.port = parsePositiveInteger(next) || DEFAULT_PORT;
+      args.__provided.port = true;
       index += 1;
     } else if (token === "--help" || token === "-h") {
       args.help = true;
@@ -42,6 +118,78 @@ function parseArgs(argv) {
   return args;
 }
 
+function isInteractiveTTY() {
+  return Boolean(process.stdin?.isTTY && process.stdout?.isTTY);
+}
+
+async function promptValue(ask, question, validate, defaultValue) {
+  while (true) {
+    const answer = normalizeText(await ask(question));
+    if (!answer && defaultValue !== undefined) return defaultValue;
+    const validated = validate(answer);
+    if (validated !== null && validated !== undefined) return validated;
+    console.error("输入无效，请重试。");
+  }
+}
+
+async function enrichArgsFromPrompt(args) {
+  if (!isInteractiveTTY() || args.help) return args;
+  const askTargets = Object.values(args.__provided || {}).some((item) => item === false) || !Array.isArray(args.degree) || args.degree.length === 0;
+  if (!askTargets) return args;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (question) => new Promise((resolve) => rl.question(question, resolve));
+  try {
+    if (!args.__provided.schoolTag) {
+      args.schoolTag = await promptValue(
+        ask,
+        `学校标签（${SCHOOL_TAG_OPTIONS.join("/")}，默认: ${args.schoolTag}）: `,
+        (value) => SCHOOL_TAG_OPTIONS.includes(value) ? value : null,
+        args.schoolTag
+      );
+    }
+    if (!args.__provided.gender) {
+      args.gender = await promptValue(
+        ask,
+        `性别（${GENDER_OPTIONS.join("/")}，默认: ${args.gender}）: `,
+        (value) => GENDER_OPTIONS.includes(value) ? value : null,
+        args.gender
+      );
+    }
+    if (!args.__provided.degree || !Array.isArray(args.degree) || args.degree.length === 0) {
+      const current = Array.isArray(args.degree) && args.degree.length > 0 ? args.degree.join(",") : "不限";
+      args.degree = await promptValue(
+        ask,
+        `学历（可多选逗号分隔，支持“本科及以上”；默认: ${current}）: `,
+        (value) => parseDegreeSelection(value),
+        Array.isArray(args.degree) && args.degree.length > 0 ? args.degree : ["不限"]
+      );
+    }
+    if (!args.__provided.recentNotView) {
+      args.recentNotView = await promptValue(
+        ask,
+        `近14天已看过滤（${RECENT_NOT_VIEW_OPTIONS.join("/")}，默认: ${args.recentNotView}）: `,
+        (value) => RECENT_NOT_VIEW_OPTIONS.includes(value) ? value : null,
+        args.recentNotView
+      );
+    }
+    if (!args.__provided.port) {
+      args.port = await promptValue(
+        ask,
+        `Chrome 调试端口（默认: ${args.port}）: `,
+        (value) => parsePositiveInteger(value),
+        args.port
+      );
+    }
+    return args;
+  } finally {
+    rl.close();
+  }
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -66,10 +214,6 @@ function generateBezierPath(start, end, steps = 18) {
   return path;
 }
 
-function normalizeText(value) {
-  return String(value || "").replace(/\s+/g, " ").trim();
-}
-
 class RecommendSearchCli {
   constructor(args) {
     this.args = args;
@@ -218,9 +362,10 @@ class RecommendSearchCli {
         return rect.width > 2 && rect.height > 2;
       };
       const school = doc.querySelector('.check-box.school');
+      const degree = doc.querySelector('.check-box.degree');
       const gender = doc.querySelector('.check-box.gender');
       const recent = doc.querySelector('.check-box.recentNotView');
-      return Boolean((school && gender && recent) || isVisible(panel));
+      return Boolean((school && degree && gender && recent) || isVisible(panel));
     })()`);
     return result === true;
   }
@@ -399,10 +544,11 @@ class RecommendSearchCli {
       if (!target) {
         return { ok: false, error: 'OPTION_NOT_FOUND', activeText };
       }
+      const targetActive = target.classList.contains('active');
       return {
         ok: true,
         activeText,
-        alreadySelected: activeText === normalize(label),
+        alreadySelected: targetActive || activeText === normalize(label),
         x: getPoint(target).x,
         y: getPoint(target).y
       };
@@ -421,6 +567,60 @@ class RecommendSearchCli {
     await sleep(humanDelay(300, 80));
   }
 
+  async getDegreeFilterState() {
+    return this.evaluate(`(() => {
+      const frame = document.querySelector('iframe[name="recommendFrame"]')
+        || document.querySelector('iframe[src*="/web/frame/recommend/"]')
+        || document.querySelector('iframe');
+      if (!frame || !frame.contentDocument) {
+        return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
+      }
+      const doc = frame.contentDocument;
+      const group = doc.querySelector('.check-box.degree');
+      if (!group) {
+        return { ok: false, error: 'GROUP_NOT_FOUND' };
+      }
+      const normalize = (value) => String(value || '').replace(/\\s+/g, '').trim();
+      const labels = ${JSON.stringify(DEGREE_OPTIONS)};
+      const activeLabels = labels.filter((label) => {
+        const node = Array.from(group.querySelectorAll('.options .option'))
+          .find((item) => normalize(item.textContent) === normalize(label));
+        return Boolean(node && node.classList.contains('active'));
+      });
+      const defaultOption = group.querySelector('.default.option');
+      return {
+        ok: true,
+        defaultActive: Boolean(defaultOption && defaultOption.classList.contains('active')),
+        activeLabels
+      };
+    })()`);
+  }
+
+  async selectDegreeFilter(labels) {
+    const targetLabels = Array.isArray(labels) && labels.length > 0 ? labels : ["不限"];
+    if (targetLabels.includes("不限")) {
+      await this.selectOption("degree", "不限");
+      return;
+    }
+
+    const currentState = await this.getDegreeFilterState();
+    if (!currentState?.ok) {
+      throw new Error(currentState?.error || "DEGREE_FILTER_STATE_FAILED");
+    }
+    const current = sortDegreeSelection(currentState.activeLabels || []);
+    const desired = sortDegreeSelection(targetLabels);
+    const same =
+      !currentState.defaultActive
+      && current.length === desired.length
+      && current.every((value, index) => value === desired[index]);
+    if (same) return;
+
+    await this.selectOption("degree", "不限");
+    for (const label of desired) {
+      await this.selectOption("degree", label);
+    }
+  }
+
   async countCandidates() {
     return this.evaluate(`(() => {
       const frame = document.querySelector('iframe[name="recommendFrame"]')
@@ -470,11 +670,14 @@ class RecommendSearchCli {
       console.log(JSON.stringify({
         status: "COMPLETED",
         result: {
-          usage: "node src/cli.js --school-tag 985 --gender 男 --recent-not-view 近14天没有 --port 9222"
+          usage: "node src/cli.js --school-tag 985 --degree 本科及以上 --gender 男 --recent-not-view 近14天没有 --port 9222"
         }
       }));
       return;
     }
+    if (!Array.isArray(this.args.degree) || this.args.degree.length === 0) {
+      throw new Error("INVALID_DEGREE_INPUT");
+    }
 
     await this.connect();
     try {
@@ -485,6 +688,7 @@ class RecommendSearchCli {
 
       await this.openFilterPanel();
       await this.selectOption("school", this.args.schoolTag);
+      await this.selectDegreeFilter(this.args.degree);
       await this.selectOption("gender", this.args.gender);
       await this.selectOption("recentNotView", this.args.recentNotView);
       await this.closeFilterPanel();
@@ -495,6 +699,7 @@ class RecommendSearchCli {
         result: {
           applied_filters: {
             school_tag: this.args.schoolTag,
+            degree: this.args.degree,
             gender: this.args.gender,
             recent_not_view: this.args.recentNotView
           },
@@ -511,9 +716,14 @@ class RecommendSearchCli {
   }
 }
 
-const args = parseArgs(process.argv.slice(2));
-const cli = new RecommendSearchCli(args);
-cli.run().catch((error) => {
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const finalArgs = await enrichArgsFromPrompt(args);
+  const cli = new RecommendSearchCli(finalArgs);
+  await cli.run();
+}
+
+main().catch((error) => {
   console.log(JSON.stringify({
     status: "FAILED",
     error: {
@@ -523,4 +733,4 @@ cli.run().catch((error) => {
     }
   }));
   process.exitCode = 1;
-});
+});