Mark Eaton
87cb70b4fb
Wire the v2 note formatter into the CLI so it can be invoked on real markdown drafts. The format-notes subcommand mirrors v1's format subcommand: parser → formatter → reassemble, with concurrent API calls. src/cmos/cli.py: - Import find_notes and format_note_entry alongside the existing v1 imports. - Add reformat_notes(text, formatter, concurrency) that finds pandoc-style markdown footnote definitions via find_notes, formats each definition's text via the v2 note formatter (or an injected fake), and substitutes the formatted text back into the original line position. Non-definition lines preserved byte-for-byte. Returns text unchanged when no definitions found. - Register the format-notes argparse subparser with the same --concurrency flag as v1's format. - Dispatch args.command == "format-notes" to reformat_notes. - Module docstring updated to document both subcommands. tests/test_cli.py: - 7 new tests for reformat_notes covering: in-place substitution, order preservation under concurrency, prose preservation, reference markers staying verbatim, no-op on empty input, trailing newline preservation. - Extended test_python_dash_m_invocation_actually_runs_main to also assert "format-notes" appears in --help, catching accidental subcommand removal. Path B integrity: formatter.py, note_formatter.py, parser.py, linter.py, harness/score.py all unchanged. No LINTER_VERSION bump. 96/96 v1 tests still passing. Total suite: 123/123. Real-API end-to-end smoke test on a temp draft with 2 footnote definitions: both reformatted byte-for-byte, prose and headings preserved, ## Conclusion section after the notes preserved.
262 lines
8.6 KiB
Python
262 lines
8.6 KiB
Python
"""Tests for src/cmos/cli.py — end-to-end draft reformatting.
|
|
|
|
The CLI orchestrates parser → formatter → reassemble. Tests inject a fake
|
|
formatter so no API calls happen; the goal is to pin the glue logic, not the
|
|
LLM behavior.
|
|
|
|
v1: ``reformat_draft`` rewrites the ``## Bibliography`` section.
|
|
v2: ``reformat_notes`` rewrites pandoc-style markdown footnote definitions
|
|
in place by line number, preserving everything else byte-for-byte.
|
|
"""
|
|
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from cmos.cli import reformat_draft, reformat_notes
|
|
from cmos.parser import NoBibliographyError
|
|
|
|
|
|
def _fake_formatter(messy: str) -> str:
|
|
# Deterministic fake: return a cleaned-up marker string so the output is
|
|
# recognizable.
|
|
return f"FORMATTED({messy.strip()})"
|
|
|
|
|
|
def test_reformat_draft_rewrites_only_bibliography_section():
|
|
draft = """\
|
|
# My Paper
|
|
|
|
Some prose with citations.
|
|
|
|
## Bibliography
|
|
|
|
yu, charles. interior chinatown. 2020.
|
|
kwon, hyeyoung. inclusion work. 2022.
|
|
"""
|
|
output = reformat_draft(draft, formatter=_fake_formatter)
|
|
assert "# My Paper" in output
|
|
assert "Some prose with citations." in output
|
|
assert "FORMATTED(yu, charles. interior chinatown. 2020.)" in output
|
|
assert "FORMATTED(kwon, hyeyoung. inclusion work. 2022.)" in output
|
|
# Original messy lines must not also survive.
|
|
assert "yu, charles. interior chinatown. 2020." not in output.replace(
|
|
"FORMATTED(yu, charles. interior chinatown. 2020.)", ""
|
|
)
|
|
|
|
|
|
def test_reformat_draft_preserves_sections_after_bibliography():
|
|
draft = """\
|
|
## Bibliography
|
|
|
|
one entry.
|
|
|
|
## Appendix
|
|
|
|
appendix text.
|
|
"""
|
|
output = reformat_draft(draft, formatter=_fake_formatter)
|
|
assert "FORMATTED(one entry.)" in output
|
|
assert "## Appendix" in output
|
|
assert "appendix text." in output
|
|
|
|
|
|
def test_reformat_draft_raises_when_no_bibliography():
|
|
with pytest.raises(NoBibliographyError):
|
|
reformat_draft("## Intro\n\nno bib here.\n", formatter=_fake_formatter)
|
|
|
|
|
|
def test_reformat_draft_bibliography_heading_preserved():
|
|
draft = "## Bibliography\n\nentry.\n"
|
|
output = reformat_draft(draft, formatter=_fake_formatter)
|
|
assert "## Bibliography" in output
|
|
|
|
|
|
def test_python_dash_m_invocation_actually_runs_main():
|
|
"""Regression test: `python -m cmos.cli` must actually invoke main().
|
|
|
|
Without an `if __name__ == "__main__"` guard at the bottom of cli.py,
|
|
`python -m cmos.cli` imports the module body but never calls main(),
|
|
so the process silently exits 0 with empty stdout. That looks
|
|
indistinguishable from a successful run that produced no output —
|
|
the worst kind of bug, since callers assume the pipeline ran. This
|
|
test forces the guard to exist by invoking the CLI as a subprocess
|
|
with --help and asserting argparse actually fired.
|
|
|
|
Also acts as a smoke test for both subcommands appearing in the
|
|
top-level help: catches the case where a future refactor removes
|
|
a subcommand registration without anyone noticing.
|
|
"""
|
|
result = subprocess.run(
|
|
[sys.executable, "-m", "cmos.cli", "--help"],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=10,
|
|
)
|
|
# argparse --help exits 0 whether or not main() ran, so the
|
|
# discriminator is the stdout content. Without main(), stdout is empty.
|
|
assert result.returncode == 0, (
|
|
f"expected exit 0, got {result.returncode}; stderr={result.stderr!r}"
|
|
)
|
|
assert result.stdout, (
|
|
"stdout was empty — `python -m cmos.cli` likely silently exited "
|
|
"without invoking main(). Check that cli.py has an "
|
|
'`if __name__ == "__main__": sys.exit(main())` guard at the bottom.'
|
|
)
|
|
assert "format" in result.stdout
|
|
assert "format-notes" in result.stdout
|
|
assert "usage" in result.stdout.lower()
|
|
|
|
|
|
# --- reformat_notes (v2 CLI plumbing) ----------------------------------------
|
|
|
|
|
|
def _fake_note_formatter(messy: str) -> str:
|
|
# Deterministic fake mirroring the v1 fake_formatter pattern.
|
|
return f"NOTE_FORMATTED({messy.strip()})"
|
|
|
|
|
|
def test_reformat_notes_substitutes_definition_in_place():
|
|
draft = """\
|
|
Some prose with a citation.[^1]
|
|
|
|
[^1]: yu, charles. interior chinatown. 2020. p 45.
|
|
"""
|
|
output = reformat_notes(draft, formatter=_fake_note_formatter)
|
|
assert "Some prose with a citation.[^1]" in output
|
|
assert "[^1]: NOTE_FORMATTED(yu, charles. interior chinatown. 2020. p 45.)" in output
|
|
# The original messy definition line must be gone.
|
|
assert "[^1]: yu, charles" not in output
|
|
|
|
|
|
def test_reformat_notes_rewrites_multiple_definitions_in_order():
|
|
draft = """\
|
|
Prose.[^1] More.[^2] Again.[^3]
|
|
|
|
[^1]: first messy.
|
|
[^2]: second messy.
|
|
[^3]: third messy.
|
|
"""
|
|
output = reformat_notes(draft, formatter=_fake_note_formatter)
|
|
assert "[^1]: NOTE_FORMATTED(first messy.)" in output
|
|
assert "[^2]: NOTE_FORMATTED(second messy.)" in output
|
|
assert "[^3]: NOTE_FORMATTED(third messy.)" in output
|
|
|
|
|
|
def test_reformat_notes_preserves_non_definition_lines():
|
|
draft = """\
|
|
# Title
|
|
|
|
Some prose with a citation.[^1]
|
|
|
|
More prose, no citation here.
|
|
|
|
[^1]: messy definition.
|
|
|
|
Conclusion paragraph.
|
|
"""
|
|
output = reformat_notes(draft, formatter=_fake_note_formatter)
|
|
assert "# Title" in output
|
|
assert "Some prose with a citation.[^1]" in output
|
|
assert "More prose, no citation here." in output
|
|
assert "Conclusion paragraph." in output
|
|
assert "[^1]: NOTE_FORMATTED(messy definition.)" in output
|
|
|
|
|
|
def test_reformat_notes_preserves_reference_markers_in_prose():
|
|
"""The [^1] reference inside the prose must NOT be touched — only
|
|
the [^1]: definition line should be reformatted."""
|
|
draft = """\
|
|
Some prose with a citation.[^1] And another.[^2]
|
|
|
|
[^1]: first.
|
|
[^2]: second.
|
|
"""
|
|
output = reformat_notes(draft, formatter=_fake_note_formatter)
|
|
# References in prose stay verbatim
|
|
assert "Some prose with a citation.[^1] And another.[^2]" in output
|
|
# Definitions are reformatted
|
|
assert "[^1]: NOTE_FORMATTED(first.)" in output
|
|
assert "[^2]: NOTE_FORMATTED(second.)" in output
|
|
|
|
|
|
def test_reformat_notes_returns_unchanged_when_no_definitions():
|
|
draft = "Just prose with no footnote definitions.\n"
|
|
output = reformat_notes(draft, formatter=_fake_note_formatter)
|
|
assert output == draft
|
|
|
|
|
|
def test_reformat_notes_preserves_trailing_newline():
|
|
with_trailing = "[^1]: messy.\n"
|
|
without_trailing = "[^1]: messy."
|
|
assert reformat_notes(with_trailing, formatter=_fake_note_formatter).endswith("\n")
|
|
assert not reformat_notes(without_trailing, formatter=_fake_note_formatter).endswith("\n")
|
|
|
|
|
|
def test_reformat_notes_preserves_order_under_concurrency():
|
|
"""With concurrent execution the formatter is called on all definitions
|
|
in parallel; the output must reassemble them in input order regardless
|
|
of which call finishes first. Mirrors the v1 order-preservation test."""
|
|
import time
|
|
|
|
def slow_fake(messy: str) -> str:
|
|
# Earlier definitions sleep longer so they finish last under naive
|
|
# completion-order tracking.
|
|
n = int(messy.split()[-1])
|
|
time.sleep(0.05 * (5 - n))
|
|
return f"NOTE_FORMATTED({messy})"
|
|
|
|
draft = """\
|
|
Prose.
|
|
|
|
[^1]: definition 0
|
|
[^2]: definition 1
|
|
[^3]: definition 2
|
|
[^4]: definition 3
|
|
[^5]: definition 4
|
|
"""
|
|
output = reformat_notes(draft, formatter=slow_fake, concurrency=4)
|
|
# Check order: each marker should be paired with its correct definition.
|
|
assert "[^1]: NOTE_FORMATTED(definition 0)" in output
|
|
assert "[^2]: NOTE_FORMATTED(definition 1)" in output
|
|
assert "[^3]: NOTE_FORMATTED(definition 2)" in output
|
|
assert "[^4]: NOTE_FORMATTED(definition 3)" in output
|
|
assert "[^5]: NOTE_FORMATTED(definition 4)" in output
|
|
|
|
|
|
def test_reformat_draft_preserves_order_under_concurrency():
|
|
# With concurrent execution the formatter is called on all entries in
|
|
# parallel; the CLI must reassemble them in input order regardless of
|
|
# which call finishes first. This test uses a fake formatter that
|
|
# sleeps based on the entry content so earlier entries finish AFTER
|
|
# later ones if order were naively tied to completion.
|
|
import time
|
|
|
|
def slow_fake(messy: str) -> str:
|
|
# Entries with lower index sleep longer so they finish last.
|
|
n = int(messy.split()[-1])
|
|
time.sleep(0.05 * (5 - n))
|
|
return f"FORMATTED({messy})"
|
|
|
|
draft = """\
|
|
## Bibliography
|
|
|
|
entry 0
|
|
entry 1
|
|
entry 2
|
|
entry 3
|
|
entry 4
|
|
"""
|
|
output = reformat_draft(draft, formatter=slow_fake, concurrency=4)
|
|
# Entries must appear in input order.
|
|
lines = [l for l in output.splitlines() if l.startswith("FORMATTED(")]
|
|
assert lines == [
|
|
"FORMATTED(entry 0)",
|
|
"FORMATTED(entry 1)",
|
|
"FORMATTED(entry 2)",
|
|
"FORMATTED(entry 3)",
|
|
"FORMATTED(entry 4)",
|
|
]
|