Skip to content

dongzhigang13305312738-art/paper-skills / bib-search-citation

bib-search-citation

Verified

Search and cite from local BibTeX/BibLaTeX .bib libraries, including Zotero exports. Use to find, filter, preview, export, or generate LaTeX/Typst citation snippets by topic, author, year, venue, DOI, arXiv ID, keywords, abstract, fields, recency, or claim support. Do not use for manuscript writing or polishing.

scripts/preview_bib_search.py

View on GitHub
#!/usr/bin/env python3
"""Render a compact human-readable preview from search_bib.py JSON output."""

from __future__ import annotations

import argparse
import json
import re
import sys
from collections.abc import Iterable
from pathlib import Path
from typing import Any

ABSTRACT_LIMIT = 240
ANNOTATION_LIMIT = 160
KEYWORDS_LIMIT = 120
WARNINGS_LIMIT = 5
WARNING_TEXT_LIMIT = 200
WHITESPACE_RE = re.compile(r"\s+")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Render a compact preview from search_bib.py JSON output."
    )
    parser.add_argument(
        "--input",
        help="Path to a JSON file generated by search_bib.py. Reads stdin when omitted.",
    )
    return parser.parse_args()


def normalize_text(value: Any) -> str:
    if value is None:
        return ""
    return WHITESPACE_RE.sub(" ", str(value)).strip()


def truncate_text(value: Any, limit: int) -> str:
    text = normalize_text(value)
    if not text or len(text) <= limit:
        return text
    return text[: max(0, limit - 3)].rstrip() + "..."


def load_payload(args: argparse.Namespace) -> dict[str, Any]:
    if args.input:
        content = Path(args.input).read_text(encoding="utf-8")
    else:
        buffer = getattr(sys.stdin, "buffer", None)
        content = buffer.read().decode("utf-8") if buffer is not None else sys.stdin.read()
    if not content.strip():
        raise ValueError("expected JSON input on stdin or via --input")

    payload = json.loads(content)
    if not isinstance(payload, dict):
        raise ValueError("preview input must be a JSON object")
    results = payload.get("results")
    if results is None or not isinstance(results, list):
        raise ValueError("preview input must contain a results list")
    meta = payload.get("meta")
    if meta is not None and not isinstance(meta, dict):
        raise ValueError("preview input meta must be an object when present")
    return payload


def render_simple_value(value: Any) -> str:
    if isinstance(value, list):
        items = [normalize_text(item) for item in value if normalize_text(item)]
        return ",".join(items) if items else "none"
    if isinstance(value, dict):
        parts = []
        for key in sorted(value):
            rendered = render_simple_value(value[key])
            if rendered != "none":
                parts.append(f"{key}={rendered}")
        return "{" + ", ".join(parts) + "}" if parts else "none"

    rendered = normalize_text(value)
    return rendered if rendered else "none"


def render_filter_summary(filters: Any) -> str:
    if not isinstance(filters, dict) or not filters:
        return "Filters: none"

    parts = []
    for key in sorted(filters):
        rendered = render_simple_value(filters[key])
        if rendered != "none":
            parts.append(f"{key}={rendered}")
    return "Filters: " + ("; ".join(parts) if parts else "none")


def render_flags(flags: Any) -> str:
    if not isinstance(flags, dict):
        return "none"
    names = [name for name in sorted(flags) if bool(flags[name])]
    return ", ".join(names) if names else "none"


def iter_citation_lines(citations: Any) -> Iterable[str]:
    if not isinstance(citations, dict):
        return []

    lines: list[str] = []
    latex = citations.get("latex")
    if isinstance(latex, dict):
        latex_parts = [
            normalize_text(latex.get("cite")),
            normalize_text(latex.get("parencite")),
            normalize_text(latex.get("textcite")),
        ]
        latex_parts = [part for part in latex_parts if part]
        if latex_parts:
            lines.append("  LaTeX: " + " | ".join(latex_parts))

    typst = citations.get("typst")
    if isinstance(typst, dict):
        typst_parts = [
            normalize_text(typst.get("inline")),
            normalize_text(typst.get("cite")),
        ]
        typst_parts = [part for part in typst_parts if part]
        if typst_parts:
            lines.append("  Typst: " + " | ".join(typst_parts))

    return lines


def render_warnings(meta: dict[str, Any]) -> list[str]:
    warnings = meta.get("parse_warnings") or []
    if not isinstance(warnings, list) or not warnings:
        return []

    lines = [f"Warnings ({len(warnings)}):"]
    for warning in warnings[:WARNINGS_LIMIT]:
        if isinstance(warning, dict):
            warning_type = normalize_text(warning.get("type")) or "warning"
            message = normalize_text(warning.get("message")) or render_simple_value(warning)
            rendered = f"[{warning_type}] {message}"
        else:
            rendered = render_simple_value(warning)
        lines.append(f"  - {truncate_text(rendered, WARNING_TEXT_LIMIT)}")

    remaining = len(warnings) - WARNINGS_LIMIT
    if remaining > 0:
        lines.append(f"  ... and {remaining} more (see meta.parse_warnings in the JSON output)")
    return lines


def render_entry(index: int, entry: dict[str, Any]) -> list[str]:
    key = normalize_text(entry.get("key")) or "<missing-key>"
    entry_type = normalize_text(entry.get("entry_type")) or "unknown"
    score = entry.get("score")
    if isinstance(score, (int, float)):
        score_text = f"{float(score):.4f}"
    else:
        score_text = normalize_text(score) or "n/a"

    lines = [
        f"{index}. {key} [{entry_type}] score={score_text} flags={render_flags(entry.get('flags'))}",
        f"  Title: {normalize_text(entry.get('title')) or '(untitled)'}",
        f"  Authors: {normalize_text(entry.get('author')) or '(unknown)'}",
    ]

    year = normalize_text(entry.get("year"))
    venue = normalize_text(entry.get("venue"))
    year_venue = " | ".join(part for part in (year, venue) if part) or "n/a"
    lines.append(f"  Year/Venue: {year_venue}")

    doi = normalize_text(entry.get("doi"))
    if doi:
        lines.append(f"  DOI: {doi}")

    eprint = normalize_text(entry.get("eprint"))
    if eprint:
        lines.append(f"  eprint: {eprint}")

    keywords = truncate_text(entry.get("keywords"), KEYWORDS_LIMIT)
    if keywords:
        lines.append(f"  Keywords: {keywords}")

    annotation = truncate_text(entry.get("annotation"), ANNOTATION_LIMIT)
    if annotation:
        lines.append(f"  Annotation: {annotation}")

    abstract = truncate_text(entry.get("abstract"), ABSTRACT_LIMIT)
    if abstract:
        lines.append(f"  Abstract: {abstract}")

    lines.extend(iter_citation_lines(entry.get("citations")))
    warnings = entry.get("warnings") or []
    if isinstance(warnings, list):
        for warning in warnings:
            lines.append(f"  Warning: {truncate_text(warning, WARNING_TEXT_LIMIT)}")
    return lines


def render_preview(payload: dict[str, Any]) -> str:
    meta = payload.get("meta") or {}
    query = normalize_text(meta.get("query")) or "(none)"
    sort_mode = normalize_text(meta.get("sort")) or "relevance"
    results = payload.get("results") or []
    returned = meta.get("returned_entries", len(results))
    matched = meta.get("matched_entries", len(results))
    total = meta.get("total_entries", matched)

    lines = [
        f"Query: {query} | sort={sort_mode} | returned={returned} of {matched} matched ({total} total)",
        render_filter_summary(meta.get("applied_filters")),
    ]
    encoding_fallback = normalize_text(meta.get("encoding_fallback"))
    if encoding_fallback:
        lines.append(f"Encoding: {encoding_fallback} fallback (file was not valid UTF-8)")
    lines.extend(render_warnings(meta))

    if not results:
        lines.append("Results: none")
        return "\n".join(lines)

    for idx, entry in enumerate(results, start=1):
        lines.append("")
        lines.extend(render_entry(idx, entry))
    return "\n".join(lines)


def _write(text: str, stream: Any) -> None:
    """Emit text as UTF-8 bytes so a legacy console locale cannot crash it (B5)."""
    buffer = getattr(stream, "buffer", None)
    if buffer is not None:
        buffer.write(text.encode("utf-8"))
        buffer.flush()
    else:
        stream.write(text)


def main() -> None:
    args = parse_args()
    try:
        payload = load_payload(args)
        preview = render_preview(payload)
    except (OSError, json.JSONDecodeError, ValueError) as exc:
        _write(json.dumps({"error": str(exc)}, ensure_ascii=False, indent=2) + "\n", sys.stderr)
        raise SystemExit(2) from exc

    _write(preview + "\n", sys.stdout)


if __name__ == "__main__":
    main()
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 196kUpdated Claude CodeCodexVerifiedInstall