Resolve \input{}/\include{} and discover inline bibliographies

Multi-file papers now load as one document: resolve_includes() inlines
\input{} / \include{} recursively (cycle-safe, tolerant of missing
targets) and produces a per-line map. Paragraph/Section/Finding carry
an origin file so findings point at the real source a user edits, not
the top-level main.tex.

Papers that ship their bibliography inline as \begin{thebibliography}
now auto-populate BibEntry records from \bibitem keys when no .bib file
is declared, so the citation checker stops emitting false MISSING
findings on that style. Bib-less runs get a single explicit warning
instead of silent degradation.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/qalmsw/bib/__init__.py

@@ -1,3 +1,4 @@
+from qalmsw.bib.inline import extract_inline_bibitems
 from qalmsw.bib.parser import BibEntry, parse_bib_file, parse_bib_text
 
-__all__ = ["BibEntry", "parse_bib_file", "parse_bib_text"]
+__all__ = ["BibEntry", "extract_inline_bibitems", "parse_bib_file", "parse_bib_text"]

src/qalmsw/bib/inline.py

@@ -0,0 +1,93 @@
+"""Extract ``\\bibitem{}`` entries from inline ``\\begin{thebibliography}`` blocks.
+
+Many papers ship a pre-formatted bibliography inside the .tex body instead of a
+separate .bib file. We scan those blocks into ``BibEntry`` objects so the citation
+checker can still cross-check ``\\cite`` keys without the user having to point at a
+.bib file by hand.
+
+Only the entry key + source line are reliable. We take a best-effort stab at the
+title (the first "quoted" or ``\\textit/\\emph``-wrapped chunk after the author list),
+but the citation checker doesn't need it; the claims checker does, and it tolerates
+empty titles by degrading to an ``info`` finding.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from qalmsw.bib.parser import BibEntry
+from qalmsw.parse.includes import LineMapEntry
+
+_THEBIB_BLOCK_RE = re.compile(
+    r"\\begin\{thebibliography\}.*?\\end\{thebibliography\}",
+    re.DOTALL,
+)
+_BIBITEM_RE = re.compile(
+    r"\\bibitem\s*(?:\[[^\]]*\])?\s*\{([^}]+)\}",
+)
+_TITLE_QUOTED_RE = re.compile(r"``([^']+?)''|\"([^\"]+?)\"")
+_TITLE_MACRO_RE = re.compile(r"\\(?:textit|emph|textbf)\s*\{([^}]+)\}")
+
+
+def extract_inline_bibitems(
+    source: str,
+    *,
+    line_map: list[LineMapEntry] | None = None,
+    default_file: Path | None = None,
+) -> list[BibEntry]:
+    """Return a ``BibEntry`` per ``\\bibitem`` found inside a ``thebibliography`` block.
+
+    When ``line_map`` is provided, each entry's ``file`` and ``line`` are translated
+    back to the file that declared them (useful when the bibliography lives in a
+    ``\\input``-ed file).
+    """
+    entries: list[BibEntry] = []
+
+    def _origin(combined_line: int) -> tuple[Path, int]:
+        if line_map is not None:
+            idx = combined_line - 1
+            if 0 <= idx < len(line_map):
+                e = line_map[idx]
+                return e.file, e.line
+        return (default_file or Path("<source>")), combined_line
+
+    for block in _THEBIB_BLOCK_RE.finditer(source):
+        block_text = block.group(0)
+        block_start = block.start()
+        # Find bibitems and the text that follows each up to the next bibitem.
+        items = list(_BIBITEM_RE.finditer(block_text))
+        for i, match in enumerate(items):
+            key = match.group(1).strip()
+            if not key:
+                continue
+            combined_line = source.count("\n", 0, block_start + match.start()) + 1
+            file, line = _origin(combined_line)
+            body_end = items[i + 1].start() if i + 1 < len(items) else len(block_text)
+            body = block_text[match.end():body_end]
+            title = _guess_title(body)
+            entries.append(
+                BibEntry(
+                    key=key,
+                    entry_type="bibitem",
+                    file=file,
+                    line=line,
+                    title=title,
+                )
+            )
+    return entries
+
+
+def _guess_title(body: str) -> str:
+    """Best-effort title guess from a \\bibitem body.
+
+    Look for a ``...''-quoted or \\textit/\\emph/\\textbf-wrapped run first; fall back
+    to empty. We don't try to be clever — getting the title wrong is fine (claims
+    degrades gracefully), getting the key wrong would be a bug.
+    """
+    m = _TITLE_QUOTED_RE.search(body)
+    if m:
+        return (m.group(1) or m.group(2) or "").strip()
+    m = _TITLE_MACRO_RE.search(body)
+    if m:
+        return m.group(1).strip()
+    return ""

src/qalmsw/checkers/claims.py

@@ -169,4 +169,10 @@ class ClaimsChecker:
 
 
 def _finding(para: Paragraph, severity: Severity, message: str) -> Finding:
-    return Finding(checker="claims", severity=severity, line=para.start_line, message=message)
+    return Finding(
+        checker="claims",
+        severity=severity,
+        line=para.start_line,
+        message=message,
+        file=str(para.file) if para.file else None,
+    )

src/qalmsw/checkers/grammar.py

@@ -70,6 +70,7 @@ def _to_finding(raw: dict, para: Paragraph, checker: str) -> Finding:
         message=raw.get("message", "").strip(),
         suggestion=(raw.get("suggestion") or None),
         excerpt=excerpt or None,
+        file=str(para.file) if para.file else None,
     )
 
 

src/qalmsw/checkers/reviewer.py

@@ -56,7 +56,11 @@ class ReviewerChecker:
         self._concurrency = concurrency
 
     def check(self, doc: Document) -> list[Finding]:
-        sections = [s for s in parse_sections(doc.source) if s.text.strip()]
+        sections = [
+            s
+            for s in parse_sections(doc.source, line_map=doc.line_map, default_file=doc.path)
+            if s.text.strip()
+        ]
         results = ordered_parallel_map(
             lambda s: self._llm.complete_json(_SYSTEM_PROMPT, self._render_user_prompt(s)),
             sections,
@@ -92,4 +96,5 @@ def _to_finding(raw: dict, section: Section, checker: str) -> Finding:
         line=section.start_line,
         message=prefix + body,
         suggestion=(raw.get("suggestion") or None),
+        file=str(section.file) if section.file else None,
     )

src/qalmsw/cli.py

@@ -7,7 +7,7 @@ import typer
 from rich.console import Console
 
 from qalmsw import __version__
-from qalmsw.bib import BibEntry, parse_bib_file
+from qalmsw.bib import BibEntry, extract_inline_bibitems, parse_bib_file
 from qalmsw.checkers import (
     Checker,
     CitationChecker,
@@ -66,6 +66,18 @@ def check(
     bib_entries = _load_bib_entries(bib_paths)
     if bib_paths:
         console.print(f"[dim]{len(bib_entries)} bib entries from {len(bib_paths)} file(s)[/]")
+    if not bib_entries:
+        inline = extract_inline_bibitems(
+            doc.source, line_map=doc.line_map, default_file=doc.path
+        )
+        if inline:
+            bib_entries = inline
+            console.print(f"[dim]{len(inline)} bib entries from inline \\begin{{thebibliography}}[/]")
+        else:
+            console.print(
+                "[yellow]warning[/]: no bib entries found (no --bib, no \\bibliography{}, "
+                "no inline \\begin{thebibliography}); citation checks will be limited."
+            )
 
     checkers: list[Checker] = [CitationChecker(bib_entries)]
     if not skip_grammar or not skip_reviewer or enable_claims:

src/qalmsw/document.py

@@ -3,13 +3,17 @@
 `Document` bundles the .tex path, full source, and parsed paragraphs so individual
 checkers don't each re-parse the file and can choose which level of detail to consume
 (raw source for citation scanning, paragraphs for grammar, etc.).
+
+``Document.source`` is the *combined* source — ``\\input{}`` / ``\\include{}`` bodies
+inlined. ``Document.line_map`` lets code translate a line in ``source`` back to its
+original file and line number, so findings keep pointing at the file the author edits.
 """
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
-from qalmsw.parse import Paragraph, parse_paragraphs
+from qalmsw.parse import LineMapEntry, Paragraph, parse_paragraphs, resolve_includes
 
 
 @dataclass(frozen=True)
@@ -17,8 +21,10 @@ class Document:
     path: Path
     source: str
     paragraphs: list[Paragraph]
+    line_map: list[LineMapEntry] = field(default_factory=list)
 
     @classmethod
     def load(cls, path: Path) -> Document:
-        source = path.read_text(encoding="utf-8")
-        return cls(path=path, source=source, paragraphs=parse_paragraphs(source))
+        source, line_map = resolve_includes(path)
+        paragraphs = parse_paragraphs(source, line_map=line_map, default_file=path)
+        return cls(path=path, source=source, paragraphs=paragraphs, line_map=line_map)

src/qalmsw/parse/__init__.py

@@ -1,15 +1,18 @@
 from qalmsw.parse.citations import CitationRef, scan_bib_resources, scan_citations
+from qalmsw.parse.includes import LineMapEntry, resolve_includes
 from qalmsw.parse.sections import Section, parse_sections
 from qalmsw.parse.tex import Paragraph, extract_body, has_prose, parse_paragraphs
 
 __all__ = [
     "CitationRef",
+    "LineMapEntry",
     "Paragraph",
     "Section",
     "extract_body",
     "has_prose",
     "parse_paragraphs",
     "parse_sections",
+    "resolve_includes",
     "scan_bib_resources",
     "scan_citations",
 ]

src/qalmsw/parse/includes.py

@@ -0,0 +1,93 @@
+"""Recursive ``\\input{}`` / ``\\include{}`` resolution.
+
+LaTeX papers commonly split source across files — ``main.tex`` pulls in
+``sections/intro.tex`` via ``\\input{}``. We inline those contents so downstream
+parsing (paragraphs, sections) sees one contiguous body, and we carry a per-line
+``LineMap`` so findings can still point at the original file + line.
+
+The resolver is conservative:
+
+- Only ``\\input`` and ``\\include`` are followed.
+- ``\\input`` inside a ``%`` comment is ignored (we strip comments first).
+- Missing include targets are replaced with empty content (so a single missing
+  file doesn't abort the run); we keep a record in ``LineMapEntry`` that points
+  back at the parent so downstream code has somewhere to anchor errors.
+- Cycle detection: a file currently on the include stack is not re-expanded.
+
+The relative-path convention matches what ``pdflatex`` does: includes are resolved
+relative to the directory of the file that declared them.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+_INCLUDE_RE = re.compile(r"\\(?:input|include)\s*\{([^}]+)\}")
+_COMMENT_RE = re.compile(r"(?<!\\)%.*")
+
+
+@dataclass(frozen=True)
+class LineMapEntry:
+    file: Path
+    line: int  # 1-indexed inside `file`
+
+
+def _resolve_target(base_dir: Path, name: str) -> Path:
+    name = name.strip()
+    candidate = Path(name)
+    if not candidate.is_absolute():
+        candidate = base_dir / candidate
+    if candidate.suffix.lower() != ".tex":
+        with_tex = candidate.with_suffix(candidate.suffix + ".tex")
+        if with_tex.exists():
+            return with_tex
+        bare = candidate.parent / (candidate.name + ".tex")
+        if bare.exists():
+            return bare
+    return candidate
+
+
+def _expand(path: Path, stack: tuple[Path, ...]) -> tuple[list[str], list[LineMapEntry]]:
+    """Return ``(lines, map)`` for ``path`` with includes inlined.
+
+    ``lines`` is a list of lines (no trailing newlines). ``map[i]`` tells you which
+    (file, line) produced ``lines[i]``.
+    """
+    if path in stack:
+        # Cycle: return the include as a literal so the check is visible, but don't recurse.
+        return ([f"% qalmsw: cycle detected, not expanding {path}"], [LineMapEntry(path, 1)])
+    try:
+        source = path.read_text(encoding="utf-8")
+    except OSError:
+        return ([f"% qalmsw: could not read {path}"], [LineMapEntry(path, 1)])
+
+    out_lines: list[str] = []
+    out_map: list[LineMapEntry] = []
+    for i, raw_line in enumerate(source.splitlines()):
+        lineno = i + 1
+        # Strip the comment part to detect \input but keep the original line intact otherwise.
+        uncommented = _COMMENT_RE.sub("", raw_line)
+        match = _INCLUDE_RE.search(uncommented)
+        if match is None:
+            out_lines.append(raw_line)
+            out_map.append(LineMapEntry(path, lineno))
+            continue
+        target = _resolve_target(path.parent, match.group(1))
+        child_lines, child_map = _expand(target, stack + (path,))
+        out_lines.extend(child_lines)
+        out_map.extend(child_map)
+    return out_lines, out_map
+
+
+def resolve_includes(path: Path) -> tuple[str, list[LineMapEntry]]:
+    """Return ``(combined_source, line_map)`` for ``path`` with includes inlined.
+
+    ``line_map[i]`` describes line ``i + 1`` of the combined source: which file it came
+    from and the 1-indexed line number inside that file.
+    """
+    lines, line_map = _expand(path, stack=())
+    combined = "\n".join(lines)
+    if combined:
+        combined += "\n"
+    return combined, line_map

src/qalmsw/parse/sections.py

@@ -2,13 +2,17 @@
 
 Used by the reviewer checker, which wants coarse section-level chunks rather than
 individual paragraphs. If the document has no `\\section{}`, the whole body is returned
-as a single untitled section.
+as a single untitled section. When a ``line_map`` is provided, each section's ``file``
+and line numbers are translated back to the file the ``\\section{}`` command was
+declared in (e.g. ``sections/intro.tex`` when pulled in via ``\\input``).
 """
 from __future__ import annotations
 
 import re
 from dataclasses import dataclass
+from pathlib import Path
 
+from qalmsw.parse.includes import LineMapEntry
 from qalmsw.parse.tex import _COMMENT_RE, extract_body
 
 _SECTION_RE = re.compile(r"\\section\*?\s*\{([^}]*)\}")
@@ -20,32 +24,52 @@ class Section:
     text: str
     start_line: int
     end_line: int
+    file: Path | None = None
 
 
-def parse_sections(source: str) -> list[Section]:
+def parse_sections(
+    source: str,
+    *,
+    line_map: list[LineMapEntry] | None = None,
+    default_file: Path | None = None,
+) -> list[Section]:
     body, body_start_line = extract_body(source)
     body = _COMMENT_RE.sub("", body)
 
+    def _origin(combined_line: int) -> tuple[Path | None, int]:
+        if line_map is None:
+            return default_file, combined_line
+        idx = combined_line - 1
+        if 0 <= idx < len(line_map):
+            entry = line_map[idx]
+            return entry.file, entry.line
+        return default_file, combined_line
+
     matches = list(_SECTION_RE.finditer(body))
     if not matches:
         total_lines = body.count("\n")
+        file, start = _origin(body_start_line)
+        _, end = _origin(body_start_line + total_lines)
         return [
             Section(
                 title="",
                 text=body.strip(),
-                start_line=body_start_line,
-                end_line=body_start_line + total_lines,
+                start_line=start,
+                end_line=end,
+                file=file,
             )
         ]
 
     sections: list[Section] = []
     for i, match in enumerate(matches):
         title = match.group(1).strip()
-        start_line = body_start_line + body.count("\n", 0, match.start())
+        start_combined = body_start_line + body.count("\n", 0, match.start())
         end_offset = matches[i + 1].start() if i + 1 < len(matches) else len(body)
-        end_line = body_start_line + body.count("\n", 0, end_offset)
+        end_combined = body_start_line + body.count("\n", 0, end_offset)
         text = body[match.start() : end_offset].strip()
+        file, start = _origin(start_combined)
+        _, end = _origin(end_combined)
         sections.append(
-            Section(title=title, text=text, start_line=start_line, end_line=end_line)
+            Section(title=title, text=text, start_line=start, end_line=end, file=file)
         )
     return sections

src/qalmsw/parse/tex.py

@@ -2,12 +2,18 @@
 
 The contract other modules rely on: `parse_paragraphs` returns `Paragraph` objects whose
 `start_line`/`end_line` are 1-indexed against the *original* file, so Findings can point
-back at the real source location.
+back at the real source location. When a ``line_map`` is provided (from
+``resolve_includes``), each paragraph's ``file`` and line numbers are translated to the
+file the content actually came from — so a finding inside ``sections/intro.tex`` renders
+with that path, not the top-level ``main.tex``.
 """
 from __future__ import annotations
 
 import re
 from dataclasses import dataclass
+from pathlib import Path
+
+from qalmsw.parse.includes import LineMapEntry
 
 _COMMENT_RE = re.compile(r"(?<!\\)%.*")
 _BEGIN_DOC_RE = re.compile(r"\\begin\{document\}")
@@ -22,6 +28,7 @@ class Paragraph:
     text: str
     start_line: int
     end_line: int
+    file: Path | None = None
 
 
 def _strip_comments(source: str) -> str:
@@ -51,8 +58,21 @@ def extract_body(source: str) -> tuple[str, int]:
     return source[offset:end_offset], start_line
 
 
-def parse_paragraphs(source: str) -> list[Paragraph]:
-    """Split the document body into blank-line-separated paragraphs."""
+def parse_paragraphs(
+    source: str,
+    *,
+    line_map: list[LineMapEntry] | None = None,
+    default_file: Path | None = None,
+) -> list[Paragraph]:
+    """Split the document body into blank-line-separated paragraphs.
+
+    If ``line_map`` is provided (as produced by ``resolve_includes``), each paragraph
+    is tagged with the file it originated from and its line numbers are translated
+    into that file's numbering. Paragraphs are attributed to the file their first
+    line belongs to; if a paragraph straddles an ``\\input{}`` boundary, the tail
+    lines' original file is discarded (rare in practice; ``\\input{}`` usually sits
+    on its own line, producing a paragraph break).
+    """
     body, body_start_line = extract_body(source)
     stripped = _strip_comments(body)
     lines = stripped.splitlines()
@@ -61,12 +81,25 @@ def parse_paragraphs(source: str) -> list[Paragraph]:
     buf: list[str] = []
     buf_start: int | None = None
 
+    def _origin(combined_line: int) -> tuple[Path | None, int]:
+        if line_map is None:
+            return default_file, combined_line
+        idx = combined_line - 1
+        if 0 <= idx < len(line_map):
+            entry = line_map[idx]
+            return entry.file, entry.line
+        return default_file, combined_line
+
     def flush(end_line: int) -> None:
         if not buf:
             return
         text = "\n".join(buf).strip()
         if text:
-            paragraphs.append(Paragraph(text=text, start_line=buf_start, end_line=end_line))
+            file, start = _origin(buf_start)
+            _, end = _origin(end_line)
+            paragraphs.append(
+                Paragraph(text=text, start_line=start, end_line=end, file=file)
+            )
         buf.clear()
 
     for i, line in enumerate(lines):

tests/test_includes.py

@@ -0,0 +1,117 @@
+from pathlib import Path
+
+from qalmsw.document import Document
+from qalmsw.parse import resolve_includes
+
+
+def _write(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+
+
+def test_no_includes_is_passthrough(tmp_path: Path):
+    main = tmp_path / "main.tex"
+    body = "\\begin{document}\nHello world.\n\\end{document}\n"
+    _write(main, body)
+    source, line_map = resolve_includes(main)
+    assert source == body
+    assert len(line_map) == body.count("\n")
+    assert all(entry.file == main for entry in line_map)
+    assert [e.line for e in line_map] == list(range(1, len(line_map) + 1))
+
+
+def test_input_inlined(tmp_path: Path):
+    main = tmp_path / "main.tex"
+    intro = tmp_path / "sections" / "intro.tex"
+    _write(intro, "Intro line one.\nIntro line two.\n")
+    _write(main, "\\begin{document}\n\\input{sections/intro}\n\\end{document}\n")
+    source, line_map = resolve_includes(main)
+    assert "Intro line one." in source
+    assert "Intro line two." in source
+    # The line containing "Intro line one." should map back to intro.tex:1.
+    lines = source.split("\n")
+    idx = lines.index("Intro line one.")
+    assert line_map[idx].file == intro
+    assert line_map[idx].line == 1
+    idx2 = lines.index("Intro line two.")
+    assert line_map[idx2].file == intro
+    assert line_map[idx2].line == 2
+
+
+def test_include_adds_tex_suffix(tmp_path: Path):
+    main = tmp_path / "main.tex"
+    sub = tmp_path / "part.tex"
+    _write(sub, "Sub content.\n")
+    _write(main, "\\input{part}\n")
+    source, line_map = resolve_includes(main)
+    assert "Sub content." in source
+    lines = source.split("\n")
+    idx = lines.index("Sub content.")
+    assert line_map[idx].file == sub
+
+
+def test_missing_include_is_tolerated(tmp_path: Path):
+    main = tmp_path / "main.tex"
+    _write(main, "Before\n\\input{does_not_exist}\nAfter\n")
+    source, line_map = resolve_includes(main)
+    assert "Before" in source
+    assert "After" in source
+    assert "qalmsw" in source  # placeholder comment emitted
+
+
+def test_cycle_detected(tmp_path: Path):
+    a = tmp_path / "a.tex"
+    b = tmp_path / "b.tex"
+    _write(a, "A\n\\input{b}\n")
+    _write(b, "B\n\\input{a}\n")
+    source, _ = resolve_includes(a)
+    # Should not infinite-loop; cycle back to a is refused.
+    assert source.count("cycle detected") >= 1
+
+
+def test_nested_includes(tmp_path: Path):
+    main = tmp_path / "main.tex"
+    mid = tmp_path / "mid.tex"
+    leaf = tmp_path / "leaf.tex"
+    _write(leaf, "Leaf content.\n")
+    _write(mid, "Mid content.\n\\input{leaf}\n")
+    _write(main, "\\input{mid}\n")
+    source, line_map = resolve_includes(main)
+    assert "Mid content." in source
+    assert "Leaf content." in source
+    lines = source.split("\n")
+    assert line_map[lines.index("Leaf content.")].file == leaf
+    assert line_map[lines.index("Mid content.")].file == mid
+
+
+def test_input_in_comment_not_followed(tmp_path: Path):
+    main = tmp_path / "main.tex"
+    _write(main, "Body\n% \\input{ignored}\n")
+    source, _ = resolve_includes(main)
+    # The commented line is kept verbatim (we preserve it as-is); we just don't follow it.
+    assert "ignored" in source  # text preserved
+    # But no separate file was created, so no expansion occurred; line count matches input.
+    assert source.count("\n") == 2
+
+
+def test_document_load_attributes_paragraphs_to_origin(tmp_path: Path):
+    main = tmp_path / "main.tex"
+    intro = tmp_path / "intro.tex"
+    _write(intro, "Paragraph from intro with enough words.\n")
+    _write(
+        main,
+        "\\begin{document}\n"
+        "\\input{intro}\n"
+        "\n"
+        "Paragraph in main.\n"
+        "\\end{document}\n",
+    )
+    doc = Document.load(main)
+    texts = [p.text for p in doc.paragraphs]
+    assert "Paragraph from intro with enough words." in texts
+    assert "Paragraph in main." in texts
+    from_intro = next(p for p in doc.paragraphs if "from intro" in p.text)
+    from_main = next(p for p in doc.paragraphs if "in main" in p.text)
+    assert from_intro.file == intro
+    assert from_intro.start_line == 1
+    assert from_main.file == main

tests/test_inline_bib.py

@@ -0,0 +1,85 @@
+from pathlib import Path
+
+from qalmsw.bib import extract_inline_bibitems
+from qalmsw.parse.includes import LineMapEntry
+
+
+def test_extracts_keys_from_thebibliography():
+    src = (
+        "\\begin{document}\n"
+        "Body.\n"
+        "\\begin{thebibliography}{99}\n"
+        "\\bibitem{foo} A. Author, ``A Title'', Venue, 2020.\n"
+        "\\bibitem{bar} B. Author, Something, 2021.\n"
+        "\\end{thebibliography}\n"
+        "\\end{document}\n"
+    )
+    entries = extract_inline_bibitems(src, default_file=Path("paper.tex"))
+    keys = [e.key for e in entries]
+    assert keys == ["foo", "bar"]
+    assert entries[0].entry_type == "bibitem"
+    assert entries[0].file == Path("paper.tex")
+    assert entries[0].line == 4
+
+
+def test_title_guessed_from_quoted_text():
+    src = (
+        "\\begin{thebibliography}{99}\n"
+        "\\bibitem{foo} A. Author, ``Attention Is All You Need'', NeurIPS, 2017.\n"
+        "\\end{thebibliography}\n"
+    )
+    entries = extract_inline_bibitems(src)
+    assert entries[0].title == "Attention Is All You Need"
+
+
+def test_title_guessed_from_textit():
+    src = (
+        "\\begin{thebibliography}{99}\n"
+        "\\bibitem{foo} A. Author, \\textit{A Book Title}, Publisher, 2020.\n"
+        "\\end{thebibliography}\n"
+    )
+    entries = extract_inline_bibitems(src)
+    assert entries[0].title == "A Book Title"
+
+
+def test_missing_title_is_empty():
+    src = (
+        "\\begin{thebibliography}{99}\n"
+        "\\bibitem{foo} A. Author. No title markup. 2020.\n"
+        "\\end{thebibliography}\n"
+    )
+    entries = extract_inline_bibitems(src)
+    assert entries[0].title == ""
+
+
+def test_no_thebibliography_yields_nothing():
+    src = "\\begin{document}\nNo bib here.\n\\end{document}\n"
+    assert extract_inline_bibitems(src) == []
+
+
+def test_bibitem_with_optional_label():
+    src = (
+        "\\begin{thebibliography}{99}\n"
+        "\\bibitem[Smith2020]{smith2020} Smith, ``X''.\n"
+        "\\end{thebibliography}\n"
+    )
+    entries = extract_inline_bibitems(src)
+    assert entries[0].key == "smith2020"
+
+
+def test_line_map_attributes_to_original_file():
+    src = (
+        "\\begin{thebibliography}{99}\n"  # combined line 1
+        "\\bibitem{foo} text.\n"  # combined line 2
+        "\\end{thebibliography}\n"  # combined line 3
+    )
+    main = Path("main.tex")
+    refs = Path("refs.tex")
+    line_map = [
+        LineMapEntry(refs, 10),
+        LineMapEntry(refs, 11),
+        LineMapEntry(refs, 12),
+    ]
+    entries = extract_inline_bibitems(src, line_map=line_map, default_file=main)
+    assert entries[0].file == refs
+    assert entries[0].line == 11