knowme-careerforge-skill 0.0.1 → 0.0.2

package/scripts/pipeline/forge.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+KnowMe CareerForge — Unified End-to-End Forge Engine
+一键打通：代码仓事实挖掘 (repo-to-resume) ➔ JD 深度解析 ➔ 多维模板检索 ➔ HTML 工作区装配 ➔ Dual-QA 质检 ➔ 确定性 PDF 导出。
+"""
+
+import sys, os, json, argparse, subprocess
+from pathlib import Path
+
+def get_project_root() -> Path:
+    curr = Path(__file__).resolve().parent
+    for _ in range(5):
+        if (curr / "SKILL.md").exists() or (curr / "package.json").exists():
+            return curr
+        curr = curr.parent
+    return Path.cwd()
+
+def main():
+    parser = argparse.ArgumentParser(description="KnowMe CareerForge — One-Shot Unified Forge Engine")
+    parser.add_argument("--repo", "-r", default=".", help="Target code repository path (default: current directory)")
+    parser.add_argument("--role", help="Target job title / role (e.g. 'AI Agent Engineer', '资深前端专家')")
+    parser.add_argument("--jd", help="Path to JD file or raw JD text")
+    parser.add_argument("--template", "-t", default="minimal", help="Template ID (minimal, modern, executive, classic)")
+    parser.add_argument("--name", help="Candidate full name override")
+    parser.add_argument("--email", help="Candidate email override")
+    parser.add_argument("--phone", help="Candidate phone override")
+    parser.add_argument("--output", "-o", default="workspace/resume.pdf", help="Output PDF file path")
+    parser.add_argument("--html-output", default="workspace/resume.html", help="Intermediate working canvas HTML path")
+    parser.add_argument("--quiet", "-q", action="store_true", help="Quiet mode (compact JSON output for AI Agent)")
+
+    args = parser.parse_args()
+    root = get_project_root()
+    scripts_dir = root / "scripts"
+
+    if not args.quiet:
+        print("==============================================================")
+        print("  KnowMe CareerForge — One-Shot Resume Engineering Pipeline")
+        print(f"  Target Role : {args.role or 'Auto-Detect'}")
+        print(f"  Repo Source : {args.repo}")
+        print(f"  Template    : {args.template}")
+        print("==============================================================")
+
+    # 1. 证据挖掘 (Stage 1: Evidence Mining)
+    evidence_json = Path("workspace/evidence-master.json")
+    
+    extract_script = scripts_dir / "evidence" / "extract-evidence.py"
+    if not extract_script.exists():
+        extract_script = scripts_dir / "extract-evidence.py"
+
+    evidence_cmd = [sys.executable, str(extract_script), "--repo", args.repo, "--output", str(evidence_json), "--quiet"]
+    if args.name: evidence_cmd.extend(["--name", args.name])
+    if args.role: evidence_cmd.extend(["--role", args.role])
+    if args.email: evidence_cmd.extend(["--email", args.email])
+    if args.phone: evidence_cmd.extend(["--phone", args.phone])
+
+    subprocess.run(evidence_cmd, check=True)
+    if not args.quiet:
+        print("[✓] Stage 1: Codebase evidence mined -> workspace/evidence-master.json")
+
+    # 2. JD 分析与关键词提取 (Stage 2: JD Analysis)
+    keywords = []
+    if args.jd:
+        try:
+            analyze_script = scripts_dir / "evidence" / "analyze-jd.py"
+            if not analyze_script.exists():
+                analyze_script = scripts_dir / "analyze-jd.py"
+
+            jd_cmd = [sys.executable, str(analyze_script)]
+            if Path(args.jd).exists():
+                jd_cmd.extend(["--jd", args.jd])
+            else:
+                jd_cmd.extend(["--text", args.jd])
+            jd_res = subprocess.run(jd_cmd, stdout=subprocess.PIPE, text=True, check=True)
+            for line in jd_res.stdout.splitlines():
+                if "Must-have Skills" in line or "Detected" in line:
+                    parts = line.split(":")[-1].strip().split(",")
+                    keywords.extend([p.strip() for p in parts if p.strip()])
+        except Exception:
+            pass
+
+    # 3. 模板装配到工作区 (Stage 3 & 4: Template Instantiation)
+    kw_arg = ",".join(keywords[:8]) if keywords else "TypeScript,Playwright,Python,Docker"
+    
+    instantiate_script = scripts_dir / "template" / "instantiate-resume.py"
+    if not instantiate_script.exists():
+        instantiate_script = scripts_dir / "instantiate-resume.py"
+
+    instantiate_cmd = [
+        sys.executable, str(instantiate_script),
+        "--template", args.template,
+        "--profile", str(evidence_json),
+        "--keywords", kw_arg,
+        "--output", args.html_output
+    ]
+    subprocess.run(instantiate_cmd, stdout=subprocess.DEVNULL if args.quiet else None, check=True)
+    if not args.quiet:
+        print(f"[✓] Stage 2: HTML Working Canvas instantiated -> {args.html_output}")
+
+    # 4. 质检与自愈校验 (Stage 5: Dual QA Validation)
+    val_script = scripts_dir / "validation" / "validate-resume.py"
+    if not val_script.exists():
+        val_script = scripts_dir / "validate-resume.py"
+
+    validator_cmd = [
+        sys.executable, str(val_script),
+        args.html_output
+    ]
+    subprocess.run(validator_cmd, stdout=subprocess.DEVNULL if args.quiet else None, check=True)
+    if not args.quiet:
+        print("[✓] Stage 3: Dual QA Validation Passed 100%")
+
+    # 5. 确定性渲染导出 PDF (Stage 6: PDF Export)
+    render_script = scripts_dir / "rendering" / "render-pdf.py"
+    if not render_script.exists():
+        render_script = scripts_dir / "render-pdf.py"
+
+    render_cmd = [
+        sys.executable, str(render_script),
+        args.html_output, args.output
+    ]
+    if args.quiet:
+        render_cmd.append("--quiet")
+    subprocess.run(render_cmd, check=True)
+
+    if not args.quiet:
+        print("==============================================================")
+        print(f"  [✓] ALL STAGES COMPLETED SUCCESSFULLY!")
+        print(f"  HTML Working Canvas : {Path(args.html_output).resolve()}")
+        print(f"  Final Verified PDF  : {Path(args.output).resolve()}")
+        print("==============================================================")
+    else:
+        result = {
+            "status": "SUCCESS",
+            "htmlCanvas": str(Path(args.html_output).resolve()),
+            "pdfDelivery": str(Path(args.output).resolve()),
+            "evidenceProfile": str(evidence_json.resolve()),
+            "templateUsed": args.template
+        }
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+
+if __name__ == "__main__":
+    main()

package/scripts/rendering/render-pdf.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""
+KnowMe CareerForge — Multi-Strategy Deterministic PDF Renderer
+多策略自愈式 A4 PDF 渲染器：自动嗅探 Playwright、系统级 Chromium/Chrome/Edge/Brave 浏览器并实现零配置确定性导出。
+"""
+
+import sys, os, subprocess, platform, shutil, argparse
+from pathlib import Path
+from typing import Optional, List
+
+def get_project_root() -> Path:
+    curr = Path(__file__).resolve().parent
+    for _ in range(5):
+        if (curr / "SKILL.md").exists() or (curr / "package.json").exists():
+            return curr
+        curr = curr.parent
+    return Path.cwd()
+
+def find_system_browser() -> Optional[str]:
+    system = platform.system()
+    
+    custom_bin = os.environ.get("CHROME_BIN") or os.environ.get("BROWSER_PATH")
+    if custom_bin and Path(custom_bin).exists():
+        return custom_bin
+
+    candidates: List[str] = []
+    
+    if system == "Darwin":  # macOS
+        candidates = [
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+            "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+            "/Applications/Chromium.app/Contents/MacOS/Chromium",
+            str(Path.home() / "Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
+            str(Path.home() / "Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"),
+        ]
+    elif system == "Linux":
+        candidates = [
+            "google-chrome", "google-chrome-stable", "chromium", "chromium-browser",
+            "/usr/bin/google-chrome", "/usr/bin/google-chrome-stable",
+            "/usr/bin/chromium", "/usr/bin/chromium-browser",
+            "/snap/bin/chromium"
+        ]
+    elif system == "Windows":
+        prog_files = os.environ.get("PROGRAMFILES", r"C:\Program Files")
+        prog_files_x86 = os.environ.get("PROGRAMFILES(X86)", r"C:\Program Files (x86)")
+        local_app = os.environ.get("LOCALAPPDATA", "")
+        
+        candidates = [
+            os.path.join(prog_files, r"Google\Chrome\Application\chrome.exe"),
+            os.path.join(prog_files_x86, r"Google\Chrome\Application\chrome.exe"),
+            os.path.join(prog_files_x86, r"Microsoft\Edge\Application\msedge.exe"),
+            os.path.join(prog_files, r"Microsoft\Edge\Application\msedge.exe"),
+            os.path.join(local_app, r"Google\Chrome\Application\chrome.exe"),
+            os.path.join(local_app, r"Microsoft\Edge\Application\msedge.exe"),
+            os.path.join(local_app, r"BraveSoftware\Brave-Browser\Application\brave.exe"),
+        ]
+
+    for candidate in candidates:
+        if candidate.startswith("/") or ":" in candidate:
+            if Path(candidate).exists():
+                return candidate
+        else:
+            resolved = shutil.which(candidate)
+            if resolved:
+                return resolved
+
+    return None
+
+def render_via_playwright(html_path: Path, pdf_path: Path) -> bool:
+    root = get_project_root()
+    script_ts = root / "scripts" / "rendering" / "render-pdf.ts"
+    if not script_ts.exists():
+        script_ts = root / "scripts" / "render-pdf.ts"
+
+    if script_ts.exists() and shutil.which("npx"):
+        try:
+            cmd = ["npx", "ts-node", str(script_ts), "--input", str(html_path), "--output", str(pdf_path)]
+            res = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=30)
+            if res.returncode == 0 and pdf_path.exists():
+                return True
+        except Exception:
+            pass
+    return False
+
+def render_via_browser(browser_bin: str, html_path: Path, pdf_path: Path) -> bool:
+    html_url = html_path.resolve().as_uri()
+    cmd = [
+        browser_bin,
+        "--headless=new",
+        "--disable-gpu",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-background-networking",
+        "--no-pdf-header-footer",
+        "--run-all-compositor-stages-before-draw",
+        f"--print-to-pdf={pdf_path.resolve()}",
+        html_url
+    ]
+    try:
+        res = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=25)
+        return pdf_path.exists() and pdf_path.stat().st_size > 0
+    except Exception as e:
+        print(f"[!] Browser render failed: {e}")
+        return False
+
+def render_pdf(html_path_str: str, pdf_path_str: str, quiet: bool = False) -> Path:
+    html_path = Path(html_path_str).resolve()
+    pdf_path = Path(pdf_path_str).resolve()
+
+    if not html_path.exists():
+        raise FileNotFoundError(f"Input HTML file does not exist: {html_path}")
+
+    pdf_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if not quiet:
+        print("==============================================================")
+        print("  KnowMe CareerForge — Multi-Strategy PDF Renderer")
+        print(f"  Source Canvas : {html_path}")
+        print(f"  Target PDF    : {pdf_path}")
+        print("==============================================================")
+
+    # Strategy 1: Playwright Headless
+    if not quiet:
+        print("[*] Strategy 1: Trying Playwright Headless Engine...")
+    if render_via_playwright(html_path, pdf_path):
+        if not quiet:
+            print(f"[✓] Render Succeeded via Playwright -> {pdf_path}")
+        return pdf_path
+
+    # Strategy 2: System Installed Chromium/Chrome/Edge/Brave
+    browser_bin = find_system_browser()
+    if browser_bin:
+        if not quiet:
+            print(f"[*] Strategy 2: Found system browser at: {browser_bin}")
+        if render_via_browser(browser_bin, html_path, pdf_path):
+            if not quiet:
+                print(f"[✓] Render Succeeded via System Browser -> {pdf_path}")
+            return pdf_path
+
+    raise RuntimeError("No suitable PDF rendering engine found. Please install Playwright or Google Chrome / Edge.")
+
+def main():
+    parser = argparse.ArgumentParser(description="KnowMe CareerForge — Multi-Strategy PDF Renderer")
+    parser.add_argument("html", nargs="?", default="workspace/resume.html", help="Input HTML canvas path")
+    parser.add_argument("pdf", nargs="?", default="workspace/resume.pdf", help="Output PDF path")
+    parser.add_argument("--input", "-i", help="Input HTML (named option)")
+    parser.add_argument("--output", "-o", help="Output PDF (named option)")
+    parser.add_argument("--quiet", "-q", action="store_true", help="Quiet execution mode")
+
+    args = parser.parse_args()
+    input_html = args.input or args.html
+    output_pdf = args.output or args.pdf
+
+    try:
+        render_pdf(input_html, output_pdf, quiet=args.quiet)
+    except Exception as e:
+        print(f"[✗] PDF Generation Failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/scripts/{render-pdf.ts → rendering/render-pdf.ts}

@@ -21,7 +21,6 @@ export async function renderResumePdf(options: RenderOptions): Promise<void> {
     throw new Error(`Input HTML file does not exist: ${absoluteHtml}`);
   }
 
-  // 确保输出目录存在
   const outputDir = path.dirname(absolutePdf);
   if (!fs.existsSync(outputDir)) {
     fs.mkdirSync(outputDir, { recursive: true });
@@ -41,8 +40,6 @@ export async function renderResumePdf(options: RenderOptions): Promise<void> {
 
   const page = await context.newPage();
   await page.goto(`file://${absoluteHtml}`, { waitUntil: 'networkidle' });
-
-  // 确保所有 Web 字体准备就绪
   await page.evaluateHandle('document.fonts.ready');
 
   await page.pdf({
@@ -69,6 +66,9 @@ async function main() {
     } else if (args[i] === '--output' || args[i] === '-o') {
       outputPdf = args[i + 1];
       i++;
+    } else if (!args[i].startsWith('-')) {
+      if (i === 0) inputHtml = args[i];
+      else if (i === 1) outputPdf = args[i];
     }
   }
 

package/scripts/template/instantiate-resume.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+KnowMe CareerForge — Resume Workspace Instantiator (Intermediate Working Canvas)
+将指定模板、候选人结构化事实档案 (evidence-master.json) 与 JD 关键词高亮组装为自包含的单文件 HTML 工作区修改场。
+"""
+
+import sys, os, json, argparse, re
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+
+def get_project_root() -> Path:
+    curr = Path(__file__).resolve().parent
+    for _ in range(5):
+        if (curr / "SKILL.md").exists() or (curr / "package.json").exists() or (curr / "src" / "templates").exists():
+            return curr
+        curr = curr.parent
+    return Path.cwd()
+
+def highlight_keywords(text: str, keywords: List[str]) -> str:
+    if not keywords or not text:
+        return text
+    for kw in keywords:
+        kw_clean = kw.strip()
+        if kw_clean:
+            pattern = re.compile(rf'(?<!<strong>)(?<![<\w/])({re.escape(kw_clean)})(?![>\w])(?!</strong>)', re.IGNORECASE)
+            text = pattern.sub(r"<strong>\1</strong>", text)
+    return text
+
+def render_profile_into_html(html_str: str, profile: Dict[str, Any], keywords: Optional[List[str]] = None) -> str:
+    basics = profile.get("basics", {})
+    name = basics.get("name", "")
+    title = basics.get("title", "")
+    phone = basics.get("phone", "")
+    email = basics.get("email", "")
+    location = basics.get("location", "")
+    github = basics.get("github", "")
+
+    # 1. 替换基础信息
+    if name:
+        html_str = re.sub(r'(<h1[^>]*class="[^"]*candidate-name[^"]*"[^>]*>).*?(</h1>)', rf'\g<1>{name}\g<2>', html_str)
+        html_str = re.sub(r'(<title>).*?(</title>)', f'<title>{name} - 个人简历</title>', html_str)
+    
+    if title:
+        html_str = re.sub(r'(<(?:p|span)[^>]*class="[^"]*(?:job-target|target-title)[^"]*"[^>]*>).*?(</(?:p|span)>)', rf'\g<1>求职意向：{title}\g<2>', html_str)
+
+    if phone:
+        html_str = re.sub(r'138-0000-0000|\b1[3-9]\d{9}\b|\+?\d{1,4}[-\s]?\d{7,11}', phone, html_str)
+    
+    if email:
+        html_str = re.sub(r'[a-zA-Z0-9_.+-]+@example\.com|[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+', email, html_str)
+
+    if location:
+        html_str = re.sub(r'北京\s*[·•-]\s*海淀(?:区)?', location, html_str)
+
+    if github:
+        html_str = re.sub(r'github\.com/[a-zA-Z0-9_-]+', github.replace("https://", "").replace("http://", ""), html_str)
+
+    # 2. 注入经历
+    experiences = profile.get("experience", [])
+    if experiences and '<section class="resume-section" id="experience">' in html_str:
+        exp_html_items = []
+        for exp in experiences:
+            bullets_html = "".join([f"<li>{highlight_keywords(b.get('text', ''), keywords or [])}</li>" for b in exp.get("bullets", [])])
+            exp_html_items.append(f"""
+        <div class="experience-item">
+          <div class="item-header">
+            <div class="item-title-group">
+              <span class="org-name">{exp.get('company', '')}</span>
+              <span class="role-badge">{exp.get('role', '')}</span>
+            </div>
+            <span class="date-range">{exp.get('startDate', '')} - {exp.get('endDate', '')}</span>
+          </div>
+          <ul class="bullet-list">
+            {bullets_html}
+          </ul>
+        </div>""")
+        
+        exp_block_pattern = re.compile(r'(<section[^>]*id="experience"[^>]*>.*?<h2[^>]*>.*?</h2>\s*).*?(</section>)', re.DOTALL)
+        if exp_block_pattern.search(html_str):
+            html_str = exp_block_pattern.sub(rf'\g<1>{"".join(exp_html_items)}\n      \g<2>', html_str)
+
+    # 3. 注入项目
+    projects = profile.get("projects", [])
+    if projects and '<section class="resume-section" id="projects">' in html_str:
+        proj_html_items = []
+        for proj in projects:
+            bullets_html = "".join([f"<li>{highlight_keywords(b.get('text', ''), keywords or [])}</li>" for b in proj.get("bullets", [])])
+            tech_tags_html = "".join([f'<span class="tech-tag">{t}</span>' for t in proj.get("techStack", [])])
+            proj_html_items.append(f"""
+        <div class="project-item">
+          <div class="item-header">
+            <div class="item-title-group">
+              <span class="project-name">{proj.get('name', '')}</span>
+              <span class="role-badge">{proj.get('role', '')}</span>
+            </div>
+            <span class="date-range">{proj.get('startDate', '')} - {proj.get('endDate', '')}</span>
+          </div>
+          <div class="tech-stack-tags">
+            {tech_tags_html}
+          </div>
+          <ul class="bullet-list">
+            {bullets_html}
+          </ul>
+        </div>""")
+        
+        proj_block_pattern = re.compile(r'(<section[^>]*id="projects"[^>]*>.*?<h2[^>]*>.*?</h2>\s*).*?(</section>)', re.DOTALL)
+        if proj_block_pattern.search(html_str):
+            html_str = proj_block_pattern.sub(rf'\g<1>{"".join(proj_html_items)}\n      \g<2>', html_str)
+
+    return html_str
+
+def instantiate_workspace(template_id: str, profile_path: Optional[str] = None, keywords: Optional[str] = None, output_path: str = "workspace/resume.html") -> Path:
+    base_dir = get_project_root()
+    template_dir = base_dir / "src" / "templates" / template_id
+    
+    if not template_dir.exists():
+        for sub in (base_dir / "src" / "templates").iterdir():
+            if sub.is_dir() and (sub / "metadata.json").exists():
+                try:
+                    meta = json.loads((sub / "metadata.json").read_text(encoding="utf-8"))
+                    if meta.get("id") == template_id:
+                        template_dir = sub
+                        break
+                except Exception:
+                    pass
+
+    if not template_dir.exists():
+        raise ValueError(f"Template '{template_id}' not found in src/templates/")
+        
+    html_file = template_dir / "template.html"
+    css_file = template_dir / "style.css"
+    
+    if not html_file.exists() or not css_file.exists():
+        raise FileNotFoundError(f"template.html or style.css missing in {template_dir}")
+        
+    html_content = html_file.read_text(encoding="utf-8")
+    css_content = css_file.read_text(encoding="utf-8")
+    
+    inlined_html = html_content.replace(
+        '<link rel="stylesheet" href="style.css">',
+        f'<style>\n{css_content}\n  </style>'
+    )
+    
+    kw_list = [k.strip() for k in keywords.split(",") if k.strip()] if keywords else []
+
+    if profile_path and Path(profile_path).exists():
+        try:
+            profile_data = json.loads(Path(profile_path).read_text(encoding="utf-8"))
+            inlined_html = render_profile_into_html(inlined_html, profile_data, kw_list)
+        except Exception as e:
+            print(f"[!] Warning: Failed to inject profile data: {e}")
+    elif kw_list:
+        inlined_html = highlight_keywords(inlined_html, kw_list)
+        
+    out_file = Path(output_path)
+    out_file.parent.mkdir(parents=True, exist_ok=True)
+    out_file.write_text(inlined_html, encoding="utf-8")
+    
+    print("==============================================================")
+    print(f"  KnowMe CareerForge — Intermediate Canvas Instantiated!")
+    print(f"  Selected Template : {template_id} ({template_dir.name})")
+    print(f"  Profile Injected  : {profile_path or 'Default Template Content'}")
+    print(f"  Working Canvas    : {out_file.resolve()}")
+    print("==============================================================")
+    return out_file
+
+def main():
+    parser = argparse.ArgumentParser(description="KnowMe CareerForge — Workspace Instantiator")
+    parser.add_argument("--template", "-t", required=True, help="Template ID (minimal, modern, executive, classic)")
+    parser.add_argument("--profile", "-p", default=None, help="Path to evidence-master.json candidate profile")
+    parser.add_argument("--keywords", "-k", default=None, help="Comma-separated keywords to highlight (e.g. 'Python,LLM,RAG')")
+    parser.add_argument("--output", "-o", default="workspace/resume.html", help="Output canvas path (default: workspace/resume.html)")
+
+    args = parser.parse_args()
+    instantiate_workspace(args.template, profile_path=args.profile, keywords=args.keywords, output_path=args.output)
+
+if __name__ == "__main__":
+    main()

package/scripts/{search-template.py → template/search-template.py}

@@ -6,9 +6,19 @@ KnowMe CareerForge — Template Search & Ranking Engine (BM25 + Multi-criteria s
 
 import sys, os, json, argparse
 from pathlib import Path
-
-def load_templates():
-    base_dir = Path(__file__).resolve().parent.parent / "src" / "templates"
+from typing import List, Dict, Any, Optional
+
+def get_project_root() -> Path:
+    curr = Path(__file__).resolve().parent
+    for _ in range(5):
+        if (curr / "SKILL.md").exists() or (curr / "package.json").exists() or (curr / "src" / "templates").exists():
+            return curr
+        curr = curr.parent
+    return Path.cwd()
+
+def load_templates() -> List[Dict[str, Any]]:
+    root_dir = get_project_root()
+    base_dir = root_dir / "src" / "templates"
     templates = []
     if not base_dir.exists():
         return templates
@@ -22,11 +32,11 @@ def load_templates():
                 data = json.loads(meta_file.read_text(encoding="utf-8"))
                 data["directory"] = f"src/templates/{t_dir.name}"
                 templates.append(data)
-            except Exception as e:
+            except Exception:
                 pass
     return templates
 
-def calculate_match_score(template, query_role, query_style=None, target_pages=1, density="balanced"):
+def calculate_match_score(template: Dict[str, Any], query_role: str, query_style: Optional[str] = None, target_pages: int = 1, density: str = "balanced") -> float:
     score = 0.0
     
     # 1. 岗位匹配度 (Role Match - 35%)
@@ -41,10 +51,12 @@ def calculate_match_score(template, query_role, query_style=None, target_pages=1
             
     if role_score < 0.5:
         cat = template.get("roleCategory", "")
-        if "tech" in query_lower or "engineer" in query_lower or "ai" in query_lower or "研发" in query_lower:
-            role_score = 0.90 if cat == "engineering-ai" else 0.40
-        elif "manage" in query_lower or "lead" in query_lower or "director" in query_lower or "总监" in query_lower or "架构" in query_lower or "产品" in query_lower:
-            role_score = 0.90 if cat == "management-product" else 0.50
+        if "ai" in query_lower or "algorithm" in query_lower or "agent" in query_lower:
+            role_score = 0.95 if cat == "engineering-ai" else 0.40
+        elif "product" in query_lower or "manager" in query_lower or "director" in query_lower:
+            role_score = 0.95 if cat == "management-product" else 0.40
+        elif "engineer" in query_lower or "architect" in query_lower:
+            role_score = 0.85
         else:
             role_score = 0.60
             
@@ -55,15 +67,16 @@ def calculate_match_score(template, query_role, query_style=None, target_pages=1
     if query_style:
         q_style_lower = query_style.lower()
         t_style = template.get("style", "").lower()
-        t_id = template.get("id", "").lower()
-        if q_style_lower in t_style or q_style_lower in t_id:
-            style_score = 1.0
-        elif "single" in q_style_lower and "single" in t_style:
+        t_tone = template.get("visualStyle", {}).get("tone", "").lower()
+        
+        if q_style_lower in t_style or q_style_lower in t_tone or q_style_lower == template.get("id"):
             style_score = 1.0
-        elif "split" in q_style_lower or "double" in q_style_lower or "column" in q_style_lower:
-            style_score = 1.0 if "two-column" in t_style else 0.50
-        elif "table" in q_style_lower or "grid" in q_style_lower:
-            style_score = 1.0 if "table" in t_style else 0.40
+        elif "minimal" in q_style_lower and "minimal" in t_style:
+            style_score = 0.95
+        elif "split" in q_style_lower and "split" in t_style:
+            style_score = 0.95
+        elif "modern" in q_style_lower and "modern" in t_tone:
+            style_score = 0.95
         else:
             style_score = 0.50
     score += style_score * 0.25
@@ -91,12 +104,10 @@ def calculate_match_score(template, query_role, query_style=None, target_pages=1
 
     return round(score * 100, 1)
 
-def search_templates(role, style=None, target_pages=1, density="balanced"):
+def search_templates(role: str, style: Optional[str] = None, target_pages: int = 1, density: str = "balanced") -> List[Dict[str, Any]]:
     templates = load_templates()
-    if not templates:
-        return []
-    
     results = []
+    
     for t in templates:
         s = calculate_match_score(t, role, style, target_pages, density)
         results.append({
@@ -109,38 +120,29 @@ def search_templates(role, style=None, target_pages=1, density="balanced"):
 
 def main():
     parser = argparse.ArgumentParser(description="KnowMe CareerForge — Template Search Engine")
-    parser.add_argument("role", nargs="?", default="AI Agent Engineer", help="Target role title (e.g. 'AI Agent Engineer', 'Frontend')")
-    parser.add_argument("--style", default=None, help="Style filter: minimal, modern, executive, classic, single-column, two-column, table")
-    parser.add_argument("--target-pages", type=int, default=1, help="Expected page count (1 or 2)")
-    parser.add_argument("--density", default="balanced", choices=["high", "balanced", "relaxed"], help="Information density")
-    parser.add_argument("--json", action="store_true", help="Output results in JSON format")
+    parser.add_argument("role", nargs="?", default="AI Agent Engineer", help="Target role title")
+    parser.add_argument("--style", "-s", default=None, help="Desired style (minimal, modern, executive, classic)")
+    parser.add_argument("--target-pages", "-p", type=int, default=1, help="Expected target pages (1 or 2)")
+    parser.add_argument("--density", "-d", default="balanced", help="Information density preference (high, balanced, normal)")
+    parser.add_argument("--json", action="store_true", help="Output results in raw JSON")
 
     args = parser.parse_args()
-
-    results = search_templates(args.role, args.style, args.target_pages, args.density)
+    results = search_templates(args.role, style=args.style, target_pages=args.target_pages, density=args.density)
 
     if args.json:
         print(json.dumps(results, ensure_ascii=False, indent=2))
         return
 
     print("=" * 80)
-    print(f"  KnowMe CareerForge — Template Search Results")
-    print(f"  Target Role : {args.role}")
-    print(f"  Style Pref  : {args.style or 'Any'}")
-    print(f"  Target Pages: {args.target_pages} | Density: {args.density}")
+    print(f"  KnowMe CareerForge — Template Recommendations for '{args.role}'")
     print("=" * 80)
-
-    if not results:
-        print("No matching templates found.")
-        return
-
     for idx, r in enumerate(results, 1):
         t = r["template"]
-        print(f"{idx}. [Score: {r['score']}] {t.get('name')} (ID: {t.get('id')})")
-        print(f"   Category: {t.get('roleCategory')} | Style: {t.get('style')} | ATS Tier: {t.get('atsScoreTier')}")
-        print(f"   Target Pages: {t.get('layout', {}).get('targetPages')} (Max: {t.get('layout', {}).get('maxPages')}) | Density: {t.get('layout', {}).get('density')}")
-        print(f"   Customizable Tokens: {', '.join(t.get('customizableTokens', [])[:4])}")
-        print(f"   Directory: {t.get('directory')}")
+        print(f"{idx}. [Score: {r['score']}] {t['name']} (ID: {t['id']})")
+        print(f"   Category: {t['roleCategory']} | Style: {t['style']} | ATS Tier: {t['atsScoreTier']}")
+        print(f"   Target Pages: {t['layout']['targetPages']} (Max: {t['layout']['maxPages']}) | Density: {t['layout']['density']}")
+        print(f"   Tone: {t['visualStyle']['tone']} | Accent: {t['visualStyle']['accentColor']}")
+        print(f"   Directory: {t['directory']}")
         print("-" * 80)
 
 if __name__ == "__main__":