ref-management 1.0.3__py3-none-any.whl

ref_management/auto_format.py

@@ -0,0 +1,106 @@
+import os
+import sys
+import subprocess
+import argparse
+import re
+from pathlib import Path
+
+def main():
+    parser = argparse.ArgumentParser(description="Another Reference Manager (ARM)")
+    parser.add_argument("document", type=Path, nargs='?', help="Path to the input .docx file")
+    parser.add_argument("--csl", type=Path, help="Path to the desired .csl file")
+    args = parser.parse_args()
+
+    # 1. Check Input Document
+    doc_path = args.document
+    if not doc_path:
+        print("\n=== ARM Manuscript Auto-Formatter (Universal CSL Edition) ===")
+        doc_input = input("Enter the path to your .docx file: ").strip().strip('"').strip("'")
+        doc_path = Path(doc_input)
+        
+    if not doc_path.exists():
+        print(f"\n❌ ERROR: Document '{doc_path}' not found.")
+        sys.exit(1)
+
+    # 2. Check CSL Input
+    csl_path = args.csl
+    if not csl_path:
+        print("\n=== Reference Formatting ===")
+        csl_input = input("Enter the CSL style name or path (e.g., nature): ").strip().strip('"').strip("'")
+        csl_path = Path(csl_input)
+
+    # --- CSL Path Resolution Logic ---
+    default_csl_dir = Path("~/citation_styles").expanduser()
+    
+    if not csl_path.exists():
+        # Check if it exists in the default directory
+        alt_path = default_csl_dir / csl_path.name
+        if alt_path.exists():
+            csl_path = alt_path
+        elif not csl_path.suffix == '.csl':
+            # Check if user forgot the .csl extension
+            alt_path_ext = default_csl_dir / f"{csl_path.name}.csl"
+            if alt_path_ext.exists():
+                csl_path = alt_path_ext
+
+    if not csl_path.exists():
+        print(f"\n❌ ERROR: CSL file '{args.csl or csl_input}' not found locally or in {default_csl_dir}.")
+        sys.exit(1)
+
+    # Use the current python executable to run subprocesses reliably
+    python_exe = sys.executable
+
+    print("\n" + "="*50)
+    print("🚀 STARTING AUTOMATED REFERENCE PIPELINE (CSL ENGINE)")
+    print("="*50)
+
+    # --- STEP 1: SCAN AND EXTRACT ---
+    print(f"\n>>> [1/3] Scanning {doc_path.name} for references...")
+    step1 = subprocess.run([python_exe, "-m", "ref_management.scan_raw_refs", str(doc_path)])
+    if step1.returncode != 0:
+        print("\n❌ ERROR: Pipeline failed during Step 1 (Scanning).")
+        sys.exit(1)
+
+    # Determine the extracted output filename based on scan_raw_refs logic
+    base_name = re.split(r'[ _]', doc_path.stem)[0] or "scan"
+    extracted_bib = Path(f"{base_name}_extracted.bib")
+    
+    if not extracted_bib.exists():
+        print(f"\n❌ ERROR: Expected intermediate file '{extracted_bib}' was not generated.")
+        sys.exit(1)
+
+    # --- STEP 2: VERIFY AND ENRICH ---
+    print(f"\n>>> [2/3] Fetching metadata from PubMed/Crossref for {extracted_bib.name}...")
+    step2 = subprocess.run([python_exe, "-m", "ref_management.verify_bib", str(extracted_bib)])
+    if step2.returncode != 0:
+        print("\n❌ ERROR: Pipeline failed during Step 2 (Verification).")
+        sys.exit(1)
+
+    verified_bib = Path(f"{base_name}_extracted_verified.bib")
+    if not verified_bib.exists():
+         print(f"\n❌ ERROR: Expected intermediate file '{verified_bib}' was not generated.")
+         sys.exit(1)
+
+    # --- STEP 3: APPLY TO MANUSCRIPT USING CSL ---
+    print(f"\n>>> [3/3] Formatting Word document using {csl_path.name}...")
+    step3 = subprocess.run([
+        python_exe, "-m", "ref_management.apply_citations",
+        str(verified_bib), 
+        str(doc_path), 
+        "--csl", str(csl_path)
+    ])
+    if step3.returncode != 0:
+        print("\n❌ ERROR: Pipeline failed during Step 3 (Formatting).")
+        sys.exit(1)
+
+    # --- WRAP UP ---
+    final_output = doc_path.with_name(f"{doc_path.stem}_final_{csl_path.stem}.docx")
+    print("\n" + "="*50)
+    print("🎉 PIPELINE COMPLETE!")
+    print("="*50)
+    print(f"✅ Final Document: {final_output}")
+    print(f"✅ Styles Applied via CSL: {csl_path.name}")
+    print(f"✅ Intermediate BibTeX files ({extracted_bib}, {verified_bib}) saved for your records.")
+
+if __name__ == "__main__":
+    main()

ref_management/generate_report.py

@@ -0,0 +1,170 @@
+import argparse
+import re
+import sys
+from pathlib import Path
+from typing import Dict, Any, Tuple, List
+
+import pyparsing
+if not hasattr(pyparsing, 'DelimitedList'):
+    if hasattr(pyparsing, 'delimited_list'): setattr(pyparsing, 'DelimitedList', pyparsing.delimited_list)
+    elif hasattr(pyparsing, 'delimitedList'): setattr(pyparsing, 'DelimitedList', pyparsing.delimitedList)
+
+import bibtexparser
+from bibtexparser.bparser import BibTexParser
+from bibtexparser import customization
+from rapidfuzz import fuzz
+
+def customizations(record: Dict[str, Any]) -> Dict[str, Any]:
+    record = customization.type(record)
+    record = customization.author(record)
+    record = customization.convert_to_unicode(record)
+    return {k if k == 'ID' else k.lower(): v for k, v in record.items()}
+
+def natural_sort_key(entry: Dict[str, Any]) -> Tuple[int, str]:
+    entry_id = entry.get('ID', '')
+    match = re.search(r'(\d+)', entry_id)
+    return (int(match.group(1)) if match else 999999, entry_id)
+
+def clean_latex(text: Any) -> str:
+    if not text: return ""
+    text_str = str(text).replace('{', '').replace('}', '')
+    replacements = {r'\"a': 'ä', r'\"o': 'ö', r'\"u': 'ü', r'\%': '%', r'\&': '&', r'\_': '_'}
+    for pat, rep in replacements.items(): text_str = text_str.replace(pat, rep)
+    return re.sub(r'\s+', ' ', text_str.replace('\\', '')).strip()
+
+def format_authors(entry: Dict[str, Any], style: str) -> str:
+    authors = entry.get('author') or entry.get('authors')
+    if not authors: return "Unknown"
+    
+    authors_list = authors.split(' and ') if isinstance(authors, str) else (authors if isinstance(authors, list) else [str(authors)])
+    formatted_list = []
+    
+    for name in authors_list:
+        clean_name = clean_latex(name).strip()
+        if ',' in clean_name:
+            parts = clean_name.split(',', 1)
+            surname = parts[0].strip()
+            initials = "".join([p.strip()[0].upper() for p in parts[1].split() if p.strip()])
+        else:
+            parts = clean_name.split()
+            surname = parts[-1] if parts else "Unknown"
+            initials = "".join([p.strip()[0].upper() for p in parts[:-1] if p.strip()]) if len(parts) > 1 else ""
+        
+        if style == 'numbered':
+            formatted_list.append(f"{surname} {initials}".strip())
+        else:
+            formatted_list.append(f"{surname}, {'.'.join(initials)}." if initials else surname)
+
+    if len(formatted_list) == 1: return formatted_list[0]
+    elif len(formatted_list) == 2: return f"{formatted_list[0]} and {formatted_list[1]}"
+    else:
+        joiner = " and " if style == 'numbered' else ", and "
+        return f"{', '.join(formatted_list[:-1])}{joiner}{formatted_list[-1]}"
+
+def format_entry(entry: Dict[str, Any], style: str) -> str:
+    authors = format_authors(entry, style)
+    year = clean_latex(entry.get('year', '????'))
+    title = clean_latex(entry.get('title', 'No Title'))
+    if title and title[-1] not in '.?!': title += "."
+    
+    journal_str = clean_latex(entry.get('journal', ''))
+    volume = clean_latex(entry.get('volume', ''))
+    pages = clean_latex(entry.get('pages', '')).replace('--', '–').replace('-', '–')
+    
+    if volume: journal_str += f" {volume}"
+    if pages: journal_str += f", {pages}" if volume else f" {pages}"
+    if journal_str and journal_str[-1] not in '.?': journal_str += "."
+
+    doi_str = f" doi: {clean_latex(entry['doi']).replace('https://doi.org/', '')}" if entry.get('doi') else ""
+    
+    if style == 'numbered':
+        return f"{authors} ({year}) {title} {journal_str}{doi_str}".strip()
+    else:
+        return f"{authors} ({year}). {title} {journal_str}{doi_str}".strip()
+
+def process_bib(input_file: Path, output_file: Path, style: str):
+    print(f"Reading {input_file} (Style: {style.upper()})...")
+    try:
+        with open(input_file, encoding='utf-8') as f:
+            parser = BibTexParser()
+            parser.customization = customizations
+            parser.common_strings = False
+            bib = parser.parse_file(f)
+    except Exception as e:
+        print(f"Error parsing BibTeX: {e}"); sys.exit(1)
+
+    # Sort based on style choice
+    if style == 'numbered':
+        sorted_entries = sorted(bib.entries, key=natural_sort_key)
+    else:
+        sorted_entries = sorted(bib.entries, key=lambda e: clean_latex(e.get('author', 'z')).lower())
+
+    seen_pmids, seen_dois, seen_titles = {}, {}, {}
+
+    try:
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(f"--- References List ({style.upper()} FORMAT | Source: {input_file.name}) ---\n\n")
+            
+            for i, entry in enumerate(sorted_entries):
+                # ID tracking
+                match = re.search(r'(\d+)', entry.get('ID', ''))
+                ref_num = match.group(1) if match else str(i + 1)
+                seq_prefix = f"{i + 1}. " if style == 'numbered' else "- "
+                
+                title = clean_latex(entry.get('title', '')).strip()
+                if not title or (title.upper() in ['REVIEWS', 'UNKNOWN', 'REFERENCES'] and 'author' not in entry): continue
+
+                dup_source = seen_pmids.get(entry.get('pmid')) or seen_dois.get(entry.get('doi'))
+                if not dup_source and len(title) > 20:
+                    norm_title = re.sub(r'[^\w]', '', title.lower())
+                    for s_title, s_info in seen_titles.items():
+                        if fuzz.ratio(norm_title, s_title) > 95:
+                            dup_source = s_info; break
+                
+                if dup_source:
+                    f.write(f"{seq_prefix}[DUPLICATE of {dup_source[0]}: {dup_source[1]}] {title[:50]}...\n\n")
+                else:
+                    if entry.get('pmid'): seen_pmids[entry['pmid']] = (ref_num, entry['ID'])
+                    if entry.get('doi'): seen_dois[entry['doi']] = (ref_num, entry['ID'])
+                    if len(title) > 20: seen_titles[re.sub(r'[^\w]', '', title.lower())] = (ref_num, entry['ID'])
+                    
+                    try:
+                        f.write(f"{seq_prefix}{format_entry(entry, style)}\n\n")
+                    except Exception as e:
+                        f.write(f"{seq_prefix}[ERROR] {e}\n\n")
+
+        print(f"Success! Saved to {output_file}")
+    except IOError as e:
+        print(f"I/O Error: {e}")
+        sys.exit(1)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", type=Path)
+    parser.add_argument("output", type=Path, nargs='?', default=None)
+    parser.add_argument("--style", choices=['1', '2', 'numbered', 'author-year'], help="1: Numbered, 2: Author-Year")
+    args = parser.parse_args()
+    
+    if not args.input.stem.endswith("_verified"):
+        candidate = args.input.with_name(f"{args.input.stem}_verified{args.input.suffix}")
+        if candidate.exists(): args.input = candidate
+            
+    style_choice = args.style
+    if not style_choice:
+        print("\n=== Select Report Output Style ===")
+        print("  1. Sequential Numbered (1. Lopez-Otin C...)")
+        print("  2. Author-Year Alphabetical (- Smith, I. (2023)...)")
+        while True:
+            choice = input("Enter 1 or 2: ").strip()
+            if choice in ['1', '2']:
+                style_choice = choice
+                break
+    
+    active_style = 'author-year' if style_choice in ['2', 'author-year'] else 'numbered'
+    if not args.output: 
+        args.output = args.input.with_name(f"{args.input.stem}_list_{active_style}.txt")
+        
+    process_bib(args.input, args.output, active_style)
+
+if __name__ == "__main__":
+    main()

ref_management/scan_raw_refs.py

@@ -0,0 +1,361 @@
+import re
+import csv
+import os
+import sys
+import argparse
+import time
+import requests
+from docx import Document
+from Bio import Entrez
+from rapidfuzz import fuzz
+
+# --- CONFIGURATION ---
+Entrez.email = os.environ.get("NCBI_EMAIL", None)
+Entrez.api_key = os.environ.get("NCBI_API_KEY", None)
+
+if Entrez.api_key is None:
+    print("Tip: Set NCBI_API_KEY environment variable to avoid request limits.", file=sys.stderr)
+
+# --- HELPERS ---
+def clean_word(word):
+    return re.sub(r'[^\w]', '', word)
+
+def resolve_doi_to_pmid(doi):
+    try:
+        clean = doi.rstrip('.').strip()
+        handle = Entrez.esearch(db="pubmed", term=f"{clean}[DOI]", retmax=1)
+        r = Entrez.read(handle)
+        handle.close()
+        return r['IdList'][0] if r['IdList'] else None
+    except Exception:
+        return None
+
+def resolve_doi_crossref(doi):
+    """Fallback for DOIs not indexed in PubMed (e.g. Stats journals, old issues)."""
+    print(f"      ...PubMed missed {doi}. Checking Crossref Master Database...", end='\r')
+    try:
+        clean = doi.rstrip('.').strip()
+        url = f"https://api.crossref.org/works/{clean}"
+        resp = requests.get(url, timeout=5)
+        if resp.status_code == 200:
+            data = resp.json().get('message', {})
+            title = data.get('title', [''])[0]
+            author_list = data.get('author', [{}])
+            first_author = author_list[0].get('family', 'Unknown') if author_list else "Unknown"
+            
+            year = "Unknown"
+            pub = data.get('published-print') or data.get('published-online')
+            if pub and 'date-parts' in pub:
+                year = str(pub['date-parts'][0][0])
+            
+            return {
+                "id": f"CR_{clean}",
+                "first_author": first_author,
+                "year": year,
+                "title": title,
+                "doi": clean,
+                "is_retracted": False
+            }
+    except Exception:
+        pass
+    return None
+
+def extract_citation_parts(text):
+    data = {"year": "", "author": "", "title_snippet": ""}
+    year_iter = list(re.finditer(r'\b(19|20)\d{2}[a-z]?\b', text))
+    
+    if year_iter:
+        selected_year_match = year_iter[0]
+        for m in year_iter:
+            if m.start() > 0 and text[m.start()-1] == '(':
+                selected_year_match = m
+                break
+                
+        raw_year = selected_year_match.group(0)
+        data["year"] = re.sub(r'[a-z]', '', raw_year)
+        
+        # Determine if Author-Year or Vancouver style based on Year placement
+        if selected_year_match.start() > len(text) / 2:
+            snippet = text[:selected_year_match.start()].strip()
+        else:
+            snippet = text[selected_year_match.end():].strip()
+            
+        # URL/DOI Scrubber (Prevents them from leaking into the Title)
+        snippet = re.sub(r'(?i)https?://\S+', '', snippet)
+        snippet = re.sub(r'(?i)doi:?\s*10\.\d{4,9}/[-._;()/:a-zA-Z0-9<>\[\]]+', '', snippet)
+        data["title_snippet"] = re.sub(r'^[\s\)\.,:;-]+|[\s\.,:;-]+$', '', snippet)
+        
+        # Improved Raw Author Parsing
+        author_raw = text[:selected_year_match.start()].split('.')[0].strip()
+        author_raw = re.sub(r'^\[?\d+\]?\s*', '', author_raw) 
+        if len(author_raw) > 3:
+            data["author"] = author_raw
+    else:
+        snippet = text
+        snippet = re.sub(r'(?i)https?://\S+', '', snippet)
+        snippet = re.sub(r'(?i)doi:?\s*10\.\d{4,9}/[-._;()/:a-zA-Z0-9<>\[\]]+', '', snippet)
+        data["title_snippet"] = snippet.strip()
+
+    if not data["author"]:
+        skip_words = {'et', 'al', 'in', 'the', 'pmid', 'doi', 'vol', 'no', 'and', '&', 'eds', 'editor', 'page', 'pp', 'references'}
+        for w in text.split():
+            clean = clean_word(w)
+            if len(clean) < 2 or clean.isdigit(): continue
+            if clean.lower() in skip_words: continue
+            if clean[0].isupper():
+                data["author"] = clean
+                break
+            
+    return data
+
+def search_pubmed_by_metadata(parts):
+    candidates = []
+    if len(parts["title_snippet"]) > 10:
+        clean_title = re.sub(r'[^\w\s]', '', parts["title_snippet"])
+        short_title = " ".join(clean_title.split()[:8])
+        try:
+            handle = Entrez.esearch(db="pubmed", term=f"{short_title}[Title]", retmax=3)
+            r = Entrez.read(handle)
+            handle.close()
+            if r['IdList']: candidates.extend(r['IdList'])
+        except Exception: pass
+    
+    if not candidates and parts["author"] and parts["year"]:
+        try:
+            handle = Entrez.esearch(db="pubmed", term=f"{parts['author'].split()[0]}[1au] AND {parts['year']}[pdat]", retmax=5)
+            r = Entrez.read(handle)
+            handle.close()
+            if r['IdList']: candidates.extend(r['IdList'])
+        except Exception: pass
+        
+    return list(set(candidates))
+
+def parse_record(record):
+    title = re.sub(r'<[^<]+?>', '', record.get('Title', ''))
+    authors = record.get('AuthorList', [])
+    first_author = authors[0] if authors else "Unknown"
+    pub_date = record.get('PubDate', '')
+    year_match = re.search(r'\d{4}', pub_date)
+    
+    doi = ""
+    for aid in record.get('ArticleIds', {}).items():
+        if aid[0] == 'doi': doi = aid[1]
+    if not doi and 'doi' in record.get('ArticleIds', {}):
+        doi = record['ArticleIds']['doi']
+
+    return {
+        "id": str(record.get('Id')),
+        "first_author": first_author,
+        "year": year_match.group(0) if year_match else "Unknown",
+        "title": title,
+        "doi": doi,
+        "is_retracted": "Retracted Publication" in record.get('PubTypeList', [])
+    }
+
+def batch_fetch_pubmed(pmid_list):
+    if not pmid_list: return {}
+    fetched_data = {}
+    unique_pmids = list(set(pmid_list))
+    
+    print(f"\nFetching metadata for {len(unique_pmids)} unique PubMed papers...")
+    for i in range(0, len(unique_pmids), 200):
+        chunk = unique_pmids[i : i + 200]
+        try:
+            handle = Entrez.esummary(db="pubmed", id=",".join(chunk), retmode="xml")
+            records = Entrez.read(handle)
+            handle.close()
+            for record in records:
+                data = parse_record(record)
+                fetched_data[data['id']] = data
+            time.sleep(0.5) 
+        except Exception as e:
+            pass
+            
+    return fetched_data
+
+# --- CORE LOGIC ---
+def analyze_document(file_path):
+    print(f"\nReading document: {file_path}...")
+    all_paragraphs = []
+    ext = os.path.splitext(file_path)[1].lower()
+    
+    try:
+        if ext == '.docx':
+            doc = Document(file_path)
+            all_paragraphs = [p.text.strip() for p in doc.paragraphs if p.text.strip()]
+        elif ext == '.txt':
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                lines = f.readlines()
+                current_block = []
+                for line in lines:
+                    if line.strip():
+                        if re.match(r'^\[?\d+[\.\)\]]', line.strip()):
+                             if current_block: all_paragraphs.append(" ".join(current_block))
+                             current_block = [line.strip()]
+                             all_paragraphs.append(line.strip())
+                             current_block = []
+                        else:
+                             current_block.append(line.strip())
+                    else:
+                        if current_block:
+                            all_paragraphs.append(" ".join(current_block))
+                            current_block = []
+                if current_block: all_paragraphs.append(" ".join(current_block))
+        else:
+            print(f"ERROR: Unsupported format {ext}"); return [], [], []
+    except Exception as e:
+        print(f"ERROR: Could not open file. {e}"); return [], [], []
+
+    header_regex = re.compile(r'^\s*(?:[0-9]+\.?\s*)?(?:REFERENCES|BIBLIOGRAPHY|LITERATURE CITED|WORKS CITED)\s*$', re.IGNORECASE)
+    start_index, header_found = 0, False
+    for i, p in enumerate(all_paragraphs):
+        if header_regex.match(p):
+            start_index, header_found = i + 1, True
+            print(f" -> Found Reference Section header. Processing subsequent text.")
+            break
+    if not header_found: print(" -> No 'References' header found. Assuming file is just a list.")
+
+    paragraphs_to_check = all_paragraphs[start_index:]
+    pmid_pattern = re.compile(r'PMID:?\s*(\d+)', re.IGNORECASE)
+    
+    # NEW DOI PATTERN: Supports <, >, and brackets used in Wiley/SICI DOIs
+    doi_pattern = re.compile(r'\b(10\.\d{4,9}/[-._;()/:a-zA-Z0-9<>\[\]]+)')
+
+    items_to_process = []
+    ids_to_fetch_metadata = set()
+
+    print(f"Scanning {len(paragraphs_to_check)} reference candidates...")
+    
+    for idx, text in enumerate(paragraphs_to_check):
+        if len(text) < 15: continue 
+
+        num_match = re.match(r'^\s*\[?(\d+)[\.\)\]]', text)
+        ref_num = num_match.group(1) if num_match else str(idx + 1)
+
+        found_pmids = [m.group(1) for m in pmid_pattern.finditer(text)]
+        found_dois = [m.group(1).rstrip('.') for m in doi_pattern.finditer(text)]
+        
+        entry = {
+            "ref_num": ref_num,
+            "original_text": text,
+            "found_pmid": found_pmids[0] if found_pmids else None,
+            "found_doi": found_dois[0] if found_dois else None,
+            "target_pmid": None,
+            "cr_meta": None,
+            "status": "PENDING",
+            "action_log": []
+        }
+
+        if entry["found_pmid"]:
+            entry["target_pmid"] = entry["found_pmid"]
+            ids_to_fetch_metadata.add(entry["target_pmid"])
+        elif entry["found_doi"]:
+            resolved_pmid = resolve_doi_to_pmid(entry["found_doi"])
+            if resolved_pmid:
+                entry["target_pmid"] = resolved_pmid
+                entry["action_log"].append("Fetched PMID via DOI")
+                ids_to_fetch_metadata.add(resolved_pmid)
+            else:
+                cr_meta = resolve_doi_crossref(entry["found_doi"])
+                if cr_meta:
+                    entry["cr_meta"] = cr_meta
+                    entry["action_log"].append("Resolved via Crossref")
+                else:
+                    entry["status"] = "FAIL_DOI_LOOKUP"
+        else:
+            if re.search(r'\b(19|20)\d{2}[a-z]?\b', text):
+                parts = extract_citation_parts(text)
+                candidates = search_pubmed_by_metadata(parts)
+                best_match, best_score = None, 0
+                if candidates:
+                    cand_meta = batch_fetch_pubmed(candidates)
+                    for c_id, c_data in cand_meta.items():
+                        score = fuzz.token_set_ratio(c_data['title'], parts['title_snippet'])
+                        if score > 80 and score > best_score:
+                            best_score, best_match = score, c_id
+                if best_match:
+                    entry["target_pmid"] = best_match
+                    entry["action_log"].append("Found via Search")
+                    ids_to_fetch_metadata.add(best_match)
+        items_to_process.append(entry)
+
+    pubmed_db = batch_fetch_pubmed(list(ids_to_fetch_metadata))
+    csv_results, txt_lines, bib_entries = [], [], []
+    
+    print("\n" + "="*85)
+    for item in items_to_process:
+        text, pmid, cr_meta = item['original_text'], item['target_pmid'], item['cr_meta']
+        meta = pubmed_db.get(pmid) if pmid else cr_meta
+        status, notes, display_id = "OK", item['action_log'], pmid if pmid else (item.get('found_doi') if cr_meta else "(No ID)")
+        
+        if not meta:
+            if item['status'] == "FAIL_DOI_LOOKUP": 
+                status, _ = "MANUAL_CHECK", notes.append("DOI not in PubMed/Crossref")
+            else: 
+                status, display_id = ("NOT_FOUND", "UNKNOWN") if re.search(r'\b(19|20)\d{2}\b', text) else ("IGNORED", display_id)
+        else:
+            title_clean = re.sub(r'[^\w\s]', '', meta['title'].lower())
+            text_clean = re.sub(r'[^\w\s]', '', text.lower())
+            title_score = fuzz.partial_ratio(title_clean, text_clean)
+            
+            if meta['is_retracted']: 
+                status = "!! RETRACTED !!"
+            elif "Found via Search" not in str(notes) and "Crossref" not in str(notes):
+                if title_score < 65:
+                    status, _ = "MISMATCH", notes.append(f"Title Score {title_score}")
+
+        if status == "IGNORED": continue 
+
+        csv_results.append({"Original_Text": text[:60] + "...", "Final_ID": display_id, "Status": status, "Notes": "; ".join(notes)})
+        
+        bib_lines = [f"@article{{{item['ref_num']},"]
+        if pmid: bib_lines.append(f"  pmid = {{{pmid}}},")
+        if meta and meta.get('doi'): bib_lines.append(f"  doi = {{{meta['doi']}}},")
+        elif item.get('found_doi'): bib_lines.append(f"  doi = {{{item['found_doi']}}},")
+        
+        if meta:
+            bib_lines.extend([f"  title = {{{meta['title']}}},", f"  author = {{{meta['first_author']} et al.}},", f"  year = {{{meta['year']}}}"])
+        else:
+            parts = extract_citation_parts(text)
+            bib_lines.append(f"  title = {{{parts['title_snippet']}}},")
+            if parts['author']: bib_lines.append(f"  author = {{{parts['author']}}},")
+            if parts['year']: bib_lines.append(f"  year = {{{parts['year']}}}")
+        bib_lines.append("}")
+        bib_entries.append("\n".join(bib_lines))
+        
+        print(f"{display_id[:15]:<18} | {status:<18} | {', '.join(notes) if notes else 'Verified'}")
+    
+    print("="*85)
+    return csv_results, txt_lines, bib_entries
+
+def save_outputs(csv_data, txt_lines, bib_entries, base_name):
+    if not csv_data: return
+    csv_name, bib_name = f"{base_name}_verification_report.csv", f"{base_name}_extracted.bib"
+
+    with open(csv_name, 'w', newline='', encoding='utf-8') as f:
+        writer = csv.DictWriter(f, fieldnames=csv_data[0].keys())
+        writer.writeheader()
+        writer.writerows(csv_data)
+        
+    with open(bib_name, 'w', encoding='utf-8') as f:
+        f.write("\n\n".join(bib_entries))
+        
+    print(f"\nSuccess! Saved outputs:")
+    print(f"  [Report] -> {csv_name}")
+    print(f"  [BibTeX] -> {bib_name}  <-- USE THIS FOR arm-verify")
+
+def main():
+    parser = argparse.ArgumentParser(description="Scan docx, output reports and a mapped .bib file.")
+    parser.add_argument("file", help="Path to .docx", nargs='?', default=None)
+    args = parser.parse_args()
+    fname = args.file
+
+    if not fname: fname = input("Enter filename (.docx): ").strip().strip('"').strip("'")
+    if not fname or not os.path.exists(fname): sys.exit(1)
+
+    base = re.split(r'[ _]', os.path.splitext(os.path.basename(fname))[0])[0] or "scan"
+    c, t, b = analyze_document(fname)
+    save_outputs(c, t, b, base)
+
+if __name__ == "__main__":
+    main()