Aggregated result from running an extractor over multiple files. ``stats`` accumulates SUCCESS outcomes plus batch-level token counts. In bat

processed man page source - the path to the original source man page name - the name of this man page as extracted by manpage.manpage syn

Per-file extraction result. For SUCCESS, ``mp`` and ``raw`` are populated. For SKIPPED/FAILED, ``error`` describes why; ``stats`` may still c

An extracted command-line option from a man page. short - a list of short options (-a, -b, ..) long - a list of long options (--a, --b) h

A single matched token span in the input command line.

Implements LLMProvider + BatchProvider for OpenAI.

Extensible bag of metrics. Adding a stat = one new field with a default. All additive fields default to zero so that aggregate accumulators (

No-op BatchManifestWriter that discards all calls.

Simple container for token counts.

Minimal Store stand-in covering the four methods Classifier/apply touch.

read/write processed man pages from sqlite

Return type for BatchProvider.collect_results.

Implements LLMProvider by shelling out to ``codex exec``. Uses ``--json`` to get JSONL output on stdout, which includes ``item.completed`` ev

Shared configuration for all extractors. ``run_dir``: single directory for all run artifacts (logs, debug files, failed responses). When set

Thread-safe manifest writer for batch extraction runs. Records batch outcomes incrementally and flushes to disk after each update.

Unrecoverable error that should abort the entire run.

Fake that satisfies BatchExtractor for isinstance checks. Uses MagicMock for method bodies so tests can inspect calls and set side_effects.

Side-band metadata attached to an extracted manpage. The extractor name itself lives on ``ParsedManpage.extractor`` (and the matching DB colu

LLM-based option extractor. Implements the base ``Extractor`` protocol via ``extract()``. Also satisfies ``BatchExtractor`` via ``prepare()``

a class to group matchresults together we group all shell results in one group and create a new group for every command

Result of LLMExtractor.prepare() — everything needed for extraction. Fields ------ synopsis: Synopsis line from lexgrog, or None.

File was intentionally skipped (not a failure).

Read-only Store variant with a size-aware LRU for repeated lookups.

Result of a single LLM call for one chunk.

Implements LLMProvider + BatchProvider for Gemini.

A file that passed the prepare phase and is ready for batch extraction.

A single entry in a batch.

Top-level manifest schema — used for reading and validation.

One batch's record in the manifest.

One file that failed extraction, with classification.

intercept log messages logged with the logging module source: https://loguru.readthedocs.io/en/stable/overview.html#entirely-compatible-with

Runtime stats for CachingStore's manpage lookup cache.

One file the extractor intentionally skipped, with classification.

Result of update_subcommand_mappings.

Tiny HTML structural counter using the standard library parser.

Aggregate LLM token usage across all successful extractions in a run.

Return value from processing one provider batch.

Cached miss for find_man_page lookups.

Thread-safe registry of in-flight provider batches. Used to cancel batches on KeyboardInterrupt so they don't linger on the provider side aft

Extractor that supports batch execution via a provider API.

Protocol for batch manifest writers used by the runner.

Batch API interface (not all providers support this).

Classification of why an extraction skipped or failed. Set at the throw site so analysis tools (e.g. report.json consumers) don't have to reg

Single-file call interface.

parse a command line and return a list of `MatchResult`s describing each token.

Distribution of per-page option counts across successful extractions.

>>> it = Peekable(iter('abc')) >>> it.index, it.peek(), it.index, it.peek(), next(it), it.index, it.peek(), next(it), next(it), it.index

Tests that @file arguments are expanded through the CLI.

Azure-prefixed models should route through the OpenAI-compatible provider.

collect_results should delete input/output/error files after collection.

Verify the manager writes results to the DB via on_result callback from run().