medsci-skills 4.1.0

package/skills/author-strategy/analyze_patterns.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+"""
+Analyze publication patterns from a PubMed CSV and generate visualizations + strategy report.
+
+Usage:
+    python analyze_patterns.py /path/to/publications.csv [--output-dir /path/to/report/]
+"""
+
+import argparse
+from collections import Counter
+from pathlib import Path
+
+import matplotlib
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+
+matplotlib.rcParams["font.family"] = "Apple SD Gothic Neo"
+matplotlib.rcParams["axes.unicode_minus"] = False
+
+COLORS = {
+    "GBD": "#e74c3c",
+    "NHIS/Claims": "#3498db",
+    "SR/MA": "#2ecc71",
+    "Cross-national": "#9b59b6",
+    "AI/ML": "#f39c12",
+    "National survey": "#1abc9c",
+    "Biobank": "#e67e22",
+    "Clinical trial": "#34495e",
+    "Letter/Commentary": "#95a5a6",
+    "Case report": "#bdc3c7",
+    "Other": "#7f8c8d",
+}
+
+
+def load_data(csv_path: str) -> pd.DataFrame:
+    df = pd.read_csv(csv_path)
+    df["year"] = pd.to_numeric(df["year"], errors="coerce")
+    return df
+
+
+def plot_yearly_stacked(df: pd.DataFrame, report_dir: Path, author_name: str):
+    fig, ax = plt.subplots(figsize=(14, 7))
+    min_year = max(int(df["year"].min()), df["year"].max() - 8) if len(df) > 50 else int(df["year"].min())
+    df_yr = df[df["year"] >= min_year].copy()
+    pivot = df_yr.groupby(["year", "study_type"]).size().unstack(fill_value=0)
+    col_order = pivot.sum().sort_values(ascending=False).index
+    pivot = pivot[col_order]
+    colors = [COLORS.get(c, "#cccccc") for c in pivot.columns]
+    pivot.plot(kind="bar", stacked=True, ax=ax, color=colors, width=0.8)
+    ax.set_xlabel("Year", fontsize=12)
+    ax.set_ylabel("Publications", fontsize=12)
+    ax.set_title(f"{author_name}: Yearly Publication Count by Study Type (N={len(df)})", fontsize=14, fontweight="bold")
+    ax.legend(title="Study Type", bbox_to_anchor=(1.02, 1), loc="upper left", fontsize=9)
+    plt.tight_layout()
+    fig.savefig(report_dir / "01_yearly_stacked.png", dpi=150, bbox_inches="tight")
+    plt.close()
+
+
+def plot_study_type_pie(df: pd.DataFrame, report_dir: Path):
+    fig, ax = plt.subplots(figsize=(10, 8))
+    counts = df["study_type"].value_counts()
+    colors = [COLORS.get(c, "#cccccc") for c in counts.index]
+    ax.pie(counts, labels=counts.index, autopct="%1.1f%%", colors=colors, pctdistance=0.85, startangle=90)
+    ax.set_title(f"Study Type Distribution (N={len(df)})", fontsize=14, fontweight="bold")
+    plt.tight_layout()
+    fig.savefig(report_dir / "02_study_type_pie.png", dpi=150, bbox_inches="tight")
+    plt.close()
+
+
+def plot_author_position(df: pd.DataFrame, report_dir: Path):
+    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
+    pos_order = ["1st", "co-1st", "middle", "co-last", "last"]
+    pos_counts = df["author_position"].value_counts().reindex(pos_order, fill_value=0)
+    colors_pos = ["#e74c3c", "#e67e22", "#95a5a6", "#3498db", "#2ecc71"]
+    bars = axes[0].bar(pos_counts.index, pos_counts.values, color=colors_pos)
+    axes[0].set_title("Author Position Overall", fontsize=12, fontweight="bold")
+    axes[0].set_ylabel("Count")
+    for bar, val in zip(bars, pos_counts.values):
+        axes[0].text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 2,
+                     f"{val}\n({val / len(df) * 100:.1f}%)", ha="center", fontsize=9)
+
+    key_types = [t for t in ["GBD", "NHIS/Claims", "SR/MA", "Cross-national", "National survey"]
+                 if t in df["study_type"].values]
+    if key_types:
+        pos_by_type = df[df["study_type"].isin(key_types)].groupby(
+            ["study_type", "author_position"]).size().unstack(fill_value=0)
+        pos_by_type = pos_by_type.reindex(columns=pos_order, fill_value=0)
+        pos_by_type.plot(kind="bar", ax=axes[1], color=colors_pos, width=0.8)
+        axes[1].set_title("Author Position by Study Type", fontsize=12, fontweight="bold")
+        axes[1].set_ylabel("Count")
+        axes[1].legend(title="Position", fontsize=8)
+        axes[1].tick_params(axis="x", rotation=0)
+
+    plt.tight_layout()
+    fig.savefig(report_dir / "03_author_position.png", dpi=150, bbox_inches="tight")
+    plt.close()
+
+
+def plot_journal_tier_heatmap(df: pd.DataFrame, report_dir: Path):
+    fig, ax = plt.subplots(figsize=(12, 8))
+    pivot = df.groupby(["study_type", "journal_tier"]).size().unstack(fill_value=0)
+    tier_order = ["Lancet family", "Nature family", "NEJM/BMJ/JAMA", "IF>=10", "Other"]
+    pivot = pivot.reindex(columns=[c for c in tier_order if c in pivot.columns], fill_value=0)
+    pivot = pivot.loc[pivot.sum(axis=1).sort_values(ascending=False).index]
+    sns.heatmap(pivot, annot=True, fmt="d", cmap="YlOrRd", ax=ax, linewidths=0.5)
+    ax.set_title("Study Type x Journal Tier (count)", fontsize=14, fontweight="bold")
+    plt.tight_layout()
+    fig.savefig(report_dir / "04_journal_tier_heatmap.png", dpi=150, bbox_inches="tight")
+    plt.close()
+
+
+def plot_topic_distribution(df: pd.DataFrame, report_dir: Path):
+    fig, ax = plt.subplots(figsize=(10, 7))
+    topic_counts = df["topic"].value_counts()
+    colors_topic = sns.color_palette("husl", len(topic_counts))
+    bars = ax.barh(topic_counts.index[::-1], topic_counts.values[::-1], color=colors_topic[::-1])
+    ax.set_xlabel("Publications")
+    ax.set_title(f"Topic Distribution (N={len(df)})", fontsize=14, fontweight="bold")
+    for bar, val in zip(bars, topic_counts.values[::-1]):
+        ax.text(bar.get_width() + 1, bar.get_y() + bar.get_height() / 2,
+                f"{val} ({val / len(df) * 100:.1f}%)", va="center", fontsize=9)
+    plt.tight_layout()
+    fig.savefig(report_dir / "05_topic_distribution.png", dpi=150, bbox_inches="tight")
+    plt.close()
+
+
+def plot_growth_curve(df: pd.DataFrame, report_dir: Path):
+    fig, ax = plt.subplots(figsize=(12, 6))
+    min_year = max(int(df["year"].min()), df["year"].max() - 10)
+    df_yr = df[df["year"] >= min_year].copy()
+    yearly = df_yr.groupby("year").size().sort_index()
+    cumulative = yearly.cumsum()
+    ax.plot(cumulative.index, cumulative.values, "o-", color="#e74c3c", linewidth=2, markersize=8)
+    ax2 = ax.twinx()
+    ax2.bar(yearly.index, yearly.values, alpha=0.3, color="#3498db")
+    ax.set_xlabel("Year")
+    ax.set_ylabel("Cumulative", color="#e74c3c")
+    ax2.set_ylabel("Yearly", color="#3498db")
+    ax.set_title("Publication Growth Curve", fontsize=14, fontweight="bold")
+    for y in cumulative.index:
+        ax.annotate(f"{cumulative[y]}", (y, cumulative[y]),
+                    textcoords="offset points", xytext=(0, 10), ha="center", fontsize=9)
+    plt.tight_layout()
+    fig.savefig(report_dir / "06_growth_curve.png", dpi=150, bbox_inches="tight")
+    plt.close()
+
+
+def plot_strategy_roi(df: pd.DataFrame, report_dir: Path):
+    fig, ax = plt.subplots(figsize=(12, 8))
+    data = []
+    for st in df["study_type"].value_counts().index:
+        subset = df[df["study_type"] == st]
+        n = len(subset)
+        high_tier = subset["journal_tier"].isin(
+            ["Lancet family", "Nature family", "NEJM/BMJ/JAMA", "IF>=10"]).mean() * 100
+        first_last = subset["author_position"].isin(["1st", "last"]).mean() * 100
+        data.append({"type": st, "count": n, "high_tier_pct": high_tier, "first_last_pct": first_last})
+    plot_df = pd.DataFrame(data)
+    ax.scatter(
+        plot_df["high_tier_pct"], plot_df["first_last_pct"],
+        s=plot_df["count"] * 3,
+        c=[COLORS.get(t, "#cccccc") for t in plot_df["type"]],
+        alpha=0.7, edgecolors="black", linewidths=0.5
+    )
+    for _, row in plot_df.iterrows():
+        ax.annotate(f'{row["type"]}\n(n={row["count"]})',
+                    (row["high_tier_pct"], row["first_last_pct"]),
+                    fontsize=8, ha="center", va="bottom")
+    ax.set_xlabel("% High-Tier Journal (IF>=10)", fontsize=12)
+    ax.set_ylabel("% 1st or Last Author", fontsize=12)
+    ax.set_title("Strategy ROI: Journal Quality vs Author Position vs Volume", fontsize=14, fontweight="bold")
+    ax.axhline(y=50, color="gray", linestyle="--", alpha=0.3)
+    ax.axvline(x=20, color="gray", linestyle="--", alpha=0.3)
+    plt.tight_layout()
+    fig.savefig(report_dir / "07_strategy_roi.png", dpi=150, bbox_inches="tight")
+    plt.close()
+
+
+def generate_report(df: pd.DataFrame, report_dir: Path, author_name: str):
+    total = len(df)
+    types = df["study_type"].value_counts()
+    positions = df["author_position"].value_counts()
+    high_tier = len(df[df["journal_tier"].isin(
+        ["Lancet family", "Nature family", "NEJM/BMJ/JAMA", "IF>=10"])])
+    first_last = len(df[df["author_position"].isin(["1st", "last"])])
+
+    # Top 3 study types
+    top_types = types.head(3)
+    type_rows = "\n".join(
+        f"| {st} | {n} | {n / total * 100:.1f}% |"
+        for st, n in top_types.items()
+    )
+
+    # Top 3 topics
+    top_topics = df["topic"].value_counts().head(5)
+    topic_rows = "\n".join(
+        f"| {tp} | {n} | {n / total * 100:.1f}% |"
+        for tp, n in top_topics.items()
+    )
+
+    # Year range
+    years = df["year"].dropna().astype(int)
+    year_range = f"{years.min()}-{years.max()}"
+    recent_year = years.max()
+    recent_count = len(df[df["year"] == recent_year])
+
+    report = f"""# {author_name} — Publication Strategy Analysis
+
+## Summary
+
+| Metric | Value |
+|--------|-------|
+| Total PubMed publications | {total} |
+| Year range | {year_range} |
+| {recent_year} publications | {recent_count} |
+| High-tier journals (Lancet/Nature/NEJM/BMJ/JAMA/IF>=10) | {high_tier} ({high_tier / total * 100:.1f}%) |
+| 1st or Last author | {first_last} ({first_last / total * 100:.1f}%) |
+
+## Study Type Breakdown
+
+| Type | Count | % |
+|------|-------|---|
+{type_rows}
+| Other | {total - top_types.sum()} | {(total - top_types.sum()) / total * 100:.1f}% |
+
+## Topic Clusters (Top 5)
+
+| Topic | Count | % |
+|-------|-------|---|
+{topic_rows}
+
+## Author Position
+
+| Position | Count | % |
+|----------|-------|---|
+| 1st author | {positions.get("1st", 0)} | {positions.get("1st", 0) / total * 100:.1f}% |
+| Last author | {positions.get("last", 0)} | {positions.get("last", 0) / total * 100:.1f}% |
+| Co-1st | {positions.get("co-1st", 0)} | {positions.get("co-1st", 0) / total * 100:.1f}% |
+| Middle | {positions.get("middle", 0)} | {positions.get("middle", 0) / total * 100:.1f}% |
+
+## Key Observations
+
+1. **Primary strategy**: {types.index[0]} ({types.iloc[0]} papers, {types.iloc[0] / total * 100:.1f}%)
+2. **Secondary strategy**: {types.index[1] if len(types) > 1 else "N/A"} ({types.iloc[1] if len(types) > 1 else 0} papers)
+3. **High-tier placement rate**: {high_tier / total * 100:.1f}%
+4. **Leadership rate** (1st + last author): {first_last / total * 100:.1f}%
+
+## Visualizations
+
+- `01_yearly_stacked.png` — yearly publication count by study type
+- `02_study_type_pie.png` — study type distribution
+- `03_author_position.png` — author position overall and by study type
+- `04_journal_tier_heatmap.png` — study type x journal tier
+- `05_topic_distribution.png` — topic clusters
+- `06_growth_curve.png` — cumulative publication growth
+- `07_strategy_roi.png` — journal quality vs author position vs volume
+
+---
+Generated: {pd.Timestamp.now().strftime('%Y-%m-%d %H:%M')}
+Data source: PubMed, {total} records
+"""
+
+    with open(report_dir / "analysis_report.md", "w") as f:
+        f.write(report)
+    print(f"Saved: analysis_report.md")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Analyze author publication patterns")
+    parser.add_argument("csv_path", help="Path to publications CSV")
+    parser.add_argument("--output-dir", "-o", help="Output directory for report", default=None)
+    parser.add_argument("--author-name", help="Author name for report title", default="Author")
+    args = parser.parse_args()
+
+    csv_path = Path(args.csv_path)
+    report_dir = Path(args.output_dir) if args.output_dir else csv_path.parent / "report"
+    report_dir.mkdir(parents=True, exist_ok=True)
+
+    df = load_data(str(csv_path))
+    print(f"Loaded {len(df)} records\n")
+
+    plot_yearly_stacked(df, report_dir, args.author_name)
+    print("Saved: 01_yearly_stacked.png")
+    plot_study_type_pie(df, report_dir)
+    print("Saved: 02_study_type_pie.png")
+    plot_author_position(df, report_dir)
+    print("Saved: 03_author_position.png")
+    plot_journal_tier_heatmap(df, report_dir)
+    print("Saved: 04_journal_tier_heatmap.png")
+    plot_topic_distribution(df, report_dir)
+    print("Saved: 05_topic_distribution.png")
+    plot_growth_curve(df, report_dir)
+    print("Saved: 06_growth_curve.png")
+    plot_strategy_roi(df, report_dir)
+    print("Saved: 07_strategy_roi.png")
+    generate_report(df, report_dir, args.author_name)
+
+    print(f"\nAll outputs in: {report_dir}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/author-strategy/fetch_pubmed.py

@@ -0,0 +1,374 @@
+#!/usr/bin/env python3
+"""
+Fetch all PubMed publications for a given author and extract metadata.
+Uses NCBI E-utilities via Biopython.
+
+Usage:
+    python fetch_pubmed.py "Author Name" [--output /path/to/output.csv] [--email user@example.com]
+"""
+
+import argparse
+import csv
+import re
+import time
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+from Bio import Entrez
+
+BATCH_SIZE = 100
+
+
+def search_pubmed(query: str) -> list[str]:
+    """Search PubMed and return all PMIDs."""
+    handle = Entrez.esearch(db="pubmed", term=query, retmax=0)
+    record = Entrez.read(handle)
+    handle.close()
+    total = int(record["Count"])
+    print(f"Total results: {total}")
+
+    pmids = []
+    for start in range(0, total, BATCH_SIZE):
+        handle = Entrez.esearch(db="pubmed", term=query, retstart=start, retmax=BATCH_SIZE)
+        record = Entrez.read(handle)
+        handle.close()
+        pmids.extend(record["IdList"])
+        time.sleep(0.4)
+    return pmids
+
+
+def classify_author_position(authors: list[dict], target_last: str) -> str:
+    """Determine author position: 1st, co-1st, corresponding, last, middle."""
+    if not authors:
+        return "unknown"
+
+    target_idx = None
+    for i, auth in enumerate(authors):
+        if auth.get("LastName", "").lower() == target_last.lower():
+            target_idx = i
+            break
+
+    if target_idx is None:
+        for i, auth in enumerate(authors):
+            if target_last.lower() in auth.get("LastName", "").lower():
+                target_idx = i
+                break
+
+    if target_idx is None:
+        return "unknown"
+
+    n = len(authors)
+    if target_idx == 0:
+        return "1st"
+    elif target_idx == n - 1:
+        return "last"
+    elif target_idx == 1 and n > 3:
+        return "co-1st"
+    elif target_idx == n - 2:
+        return "co-last"
+    else:
+        return "middle"
+
+
+def classify_study_type(title: str, abstract: str, mesh_terms: list[str], pub_types: list[str]) -> str:
+    """Classify study type based on title, abstract, MeSH, and publication types."""
+    text = (title + " " + abstract).lower()
+    mesh_lower = " ".join(mesh_terms).lower()
+    pub_lower = " ".join(pub_types).lower()
+
+    # GBD
+    if "global burden" in text or "gbd" in text:
+        return "GBD"
+
+    # SR/MA
+    if ("systematic review" in text or "meta-analysis" in text or
+            "systematic review" in pub_lower or "meta-analysis" in pub_lower):
+        return "SR/MA"
+
+    # National health insurance claims
+    if ("national health insurance" in text or "nhis" in text or
+            "claims database" in text or "nationwide cohort" in text):
+        return "NHIS/Claims"
+
+    # Cross-national / binational
+    if ("cross-national" in text or "binational" in text or
+            ("korea" in text and ("united states" in text or "japan" in text or
+             "france" in text or "american" in text))):
+        return "Cross-national"
+
+    # National survey (KNHANES, NHANES, etc.)
+    if ("knhanes" in text or "nhanes" in text or "national health and nutrition" in text or
+            "kchs" in text or "national survey" in text):
+        return "National survey"
+
+    # Biobank
+    if "biobank" in text:
+        return "Biobank"
+
+    # AI/ML
+    if ("machine learning" in text or "deep learning" in text or
+            "artificial intelligence" in text or "neural network" in text):
+        return "AI/ML"
+
+    # Clinical trial
+    if "randomized" in text or "clinical trial" in pub_lower:
+        return "Clinical trial"
+
+    # Case report
+    if "case report" in text or "case report" in pub_lower:
+        return "Case report"
+
+    # Letter/Commentary
+    if "letter" in pub_lower or "comment" in pub_lower or "editorial" in pub_lower:
+        return "Letter/Commentary"
+
+    return "Other"
+
+
+def classify_topic(title: str, abstract: str, mesh_terms: list[str]) -> str:
+    """Classify topic cluster."""
+    text = (title + " " + abstract).lower()
+
+    topics = {
+        "Allergy/Respiratory": ["allergy", "allergic", "asthma", "respiratory", "atopic",
+                                 "rhinitis", "eczema", "copd", "pneumonia", "lung disease"],
+        "Cardiovascular": ["cardiovascular", "coronary", "heart", "myocardial", "hypertension",
+                          "stroke", "atherosclerosis", "arrhythmia"],
+        "Mental health": ["depression", "anxiety", "mental health", "psychiatric", "suicide",
+                         "adhd", "autism", "bipolar", "schizophrenia"],
+        "Infectious": ["covid", "sars-cov", "infection", "vaccine", "vaccination", "herpes zoster",
+                       "influenza", "hepatitis", "tuberculosis"],
+        "Oncology": ["cancer", "tumor", "malignant", "neoplasm", "carcinoma", "leukemia",
+                     "lymphoma"],
+        "Metabolic": ["diabetes", "obesity", "metabolic", "lipid", "cholesterol", "fatty liver",
+                      "bmi", "insulin"],
+        "Nutrition/Lifestyle": ["diet", "nutrition", "physical activity", "exercise", "sleep",
+                                "sedentary", "alcohol", "smoking"],
+        "Musculoskeletal": ["osteoporosis", "fracture", "arthritis", "bone", "sarcopenia",
+                           "musculoskeletal", "spine", "joint"],
+        "Neurological": ["dementia", "alzheimer", "parkinson", "epilepsy", "migraine",
+                        "cerebrovascular", "brain", "cognitive"],
+        "Radiology/Imaging": ["radiolog", "imaging", "ct ", "mri", "ultrasound", "x-ray",
+                              "mammograph", "pet", "contrast"],
+        "GI/Hepatology": ["gastro", "liver", "hepat", "pancrea", "colon", "bowel",
+                          "endoscop", "cirrhosis"],
+        "Ophthalmology": ["ophthalm", "vision", "macular", "retinal", "eye", "glaucoma"],
+        "Pediatrics": ["child", "pediatric", "adolescent", "infant", "neonatal", "prenatal",
+                       "offspring"],
+    }
+
+    scores = {}
+    for topic, keywords in topics.items():
+        score = sum(1 for kw in keywords if kw in text)
+        if score > 0:
+            scores[topic] = score
+
+    if not scores:
+        return "Other"
+
+    return max(scores, key=scores.get)
+
+
+def classify_journal_tier(journal: str) -> str:
+    """Classify journal into tiers."""
+    j = journal.lower()
+
+    lancet_family = ["lancet"]
+    nature_family = ["nature", "nat med", "nat rev", "nat commun"]
+    nejm_bmj = ["n engl j med", "bmj", "jama"]
+
+    if any(x in j for x in lancet_family):
+        return "Lancet family"
+    if any(x in j for x in nature_family):
+        return "Nature family"
+    if any(x in j for x in nejm_bmj):
+        return "NEJM/BMJ/JAMA"
+
+    high_if = ["circulation", "eur heart j", "allergy", "j allergy clin immunol",
+               "ebiomedic", "sci adv", "cell", "ann oncol", "gut", "radiology",
+               "eur radiol", "invest radiol"]
+    if any(x in j for x in high_if):
+        return "IF>=10"
+
+    return "Other"
+
+
+def parse_article(article, target_last: str) -> dict:
+    """Parse a single PubmedArticle XML element."""
+    medline = article.find(".//MedlineCitation")
+    art = medline.find(".//Article") if medline is not None else None
+
+    pmid = ""
+    pmid_el = medline.find(".//PMID") if medline is not None else None
+    if pmid_el is not None:
+        pmid = pmid_el.text or ""
+
+    title = ""
+    title_el = art.find(".//ArticleTitle") if art is not None else None
+    if title_el is not None:
+        title = "".join(title_el.itertext()).strip()
+
+    journal = ""
+    journal_el = art.find(".//Journal/Title") if art is not None else None
+    if journal_el is not None:
+        journal = journal_el.text or ""
+
+    journal_abbrev = ""
+    ja_el = art.find(".//Journal/ISOAbbreviation") if art is not None else None
+    if ja_el is not None:
+        journal_abbrev = ja_el.text or ""
+
+    year = ""
+    year_el = art.find(".//Journal/JournalIssue/PubDate/Year") if art is not None else None
+    if year_el is not None:
+        year = year_el.text or ""
+    else:
+        medline_date = art.find(".//Journal/JournalIssue/PubDate/MedlineDate") if art is not None else None
+        if medline_date is not None and medline_date.text:
+            match = re.search(r"(20\d{2}|19\d{2})", medline_date.text)
+            if match:
+                year = match.group(1)
+
+    authors = []
+    author_list = art.find(".//AuthorList") if art is not None else None
+    if author_list is not None:
+        for auth_el in author_list.findall("Author"):
+            last = auth_el.find("LastName")
+            fore = auth_el.find("ForeName")
+            initials = auth_el.find("Initials")
+            collective = auth_el.find("CollectiveName")
+            auth_dict = {
+                "LastName": last.text if last is not None else "",
+                "ForeName": fore.text if fore is not None else "",
+                "Initials": initials.text if initials is not None else "",
+                "CollectiveName": collective.text if collective is not None else "",
+            }
+            authors.append(auth_dict)
+
+    n_authors = len(authors)
+    author_position = classify_author_position(authors, target_last)
+
+    abstract = ""
+    abstract_el = art.find(".//Abstract") if art is not None else None
+    if abstract_el is not None:
+        parts = []
+        for at in abstract_el.findall("AbstractText"):
+            parts.append("".join(at.itertext()).strip())
+        abstract = " ".join(parts)
+
+    mesh_terms = []
+    mesh_list = medline.find(".//MeshHeadingList") if medline is not None else None
+    if mesh_list is not None:
+        for mh in mesh_list.findall("MeshHeading"):
+            desc = mh.find("DescriptorName")
+            if desc is not None:
+                mesh_terms.append(desc.text or "")
+
+    pub_types = []
+    pt_list = art.find(".//PublicationTypeList") if art is not None else None
+    if pt_list is not None:
+        for pt in pt_list.findall("PublicationType"):
+            pub_types.append(pt.text or "")
+
+    study_type = classify_study_type(title, abstract, mesh_terms, pub_types)
+    topic = classify_topic(title, abstract, mesh_terms)
+    journal_tier = classify_journal_tier(journal_abbrev or journal)
+
+    return {
+        "pmid": pmid,
+        "title": title,
+        "journal": journal,
+        "journal_abbrev": journal_abbrev,
+        "year": year,
+        "n_authors": n_authors,
+        "author_position": author_position,
+        "study_type": study_type,
+        "topic": topic,
+        "journal_tier": journal_tier,
+        "pub_types": "; ".join(pub_types),
+        "mesh_terms": "; ".join(mesh_terms),
+        "abstract": abstract[:500],
+    }
+
+
+def fetch_details(pmids: list[str], target_last: str) -> list[dict]:
+    """Fetch detailed metadata for a list of PMIDs."""
+    all_records = []
+    for start in range(0, len(pmids), BATCH_SIZE):
+        batch = pmids[start:start + BATCH_SIZE]
+        print(f"Fetching details {start+1}-{start+len(batch)} of {len(pmids)}...")
+        handle = Entrez.efetch(db="pubmed", id=batch, rettype="xml", retmode="xml")
+        xml_data = handle.read()
+        handle.close()
+        root = ET.fromstring(xml_data)
+        for article in root.findall(".//PubmedArticle"):
+            record = parse_article(article, target_last)
+            all_records.append(record)
+        time.sleep(0.5)
+    return all_records
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fetch PubMed publications for an author")
+    parser.add_argument("author", help="Author name for PubMed search (e.g., 'Kim DK')")
+    parser.add_argument("--last-name", help="Last name for position classification (auto-detected if omitted)")
+    parser.add_argument("--output", "-o", help="Output CSV path", default=None)
+    parser.add_argument("--email", help="Email for NCBI E-utilities", default="research@example.com")
+    args = parser.parse_args()
+
+    Entrez.email = args.email
+
+    # Build search query
+    search_query = f'"{args.author}"[Author]'
+    target_last = args.last_name or args.author.split()[-1]
+
+    # Output path
+    if args.output:
+        output_csv = Path(args.output)
+    else:
+        safe_name = args.author.replace(" ", "_").replace('"', "")
+        output_csv = Path(f"{safe_name}_publications.csv")
+
+    print(f"Searching PubMed for: {search_query}")
+    print(f"Target last name for position: {target_last}")
+    pmids = search_pubmed(search_query)
+    print(f"Found {len(pmids)} PMIDs")
+
+    if not pmids:
+        print("No results found. Check the author name format.")
+        return
+
+    records = fetch_details(pmids, target_last)
+    print(f"Fetched details for {len(records)} articles")
+
+    output_csv.parent.mkdir(parents=True, exist_ok=True)
+    fieldnames = [
+        "pmid", "title", "journal", "journal_abbrev", "year",
+        "n_authors", "author_position", "study_type", "topic",
+        "journal_tier", "pub_types", "mesh_terms", "abstract"
+    ]
+
+    with open(output_csv, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(records)
+
+    print(f"\nSaved to {output_csv}")
+    print(f"Total records: {len(records)}")
+
+    # Quick summary
+    from collections import Counter
+    types = Counter(r["study_type"] for r in records)
+    positions = Counter(r["author_position"] for r in records)
+
+    print("\n=== Study Type Distribution ===")
+    for k, v in types.most_common():
+        print(f"  {k}: {v} ({v/len(records)*100:.1f}%)")
+
+    print("\n=== Author Position ===")
+    for k, v in positions.most_common():
+        print(f"  {k}: {v} ({v/len(records)*100:.1f}%)")
+
+
+if __name__ == "__main__":
+    main()