pystylometry 1.3.1__py3-none-any.whl → 1.3.6__py3-none-any.whl

pystylometry/cli.py

@@ -3,6 +3,8 @@
 Usage:
     pystylometry-drift <file> [--window-size=N] [--stride=N] [--mode=MODE] [--json]
     pystylometry-drift <file> --plot [output.png]
+    pystylometry-tokenize <file> [--json] [--metadata] [--stats]
+    bnc --input-file <file> [--output-file <file>] [--format csv|html|json]
 
 Example:
     pystylometry-drift manuscript.txt
@@ -10,6 +12,12 @@ Example:
     pystylometry-drift manuscript.txt --json
     pystylometry-drift manuscript.txt --plot
     pystylometry-drift manuscript.txt --plot drift_report.png
+    pystylometry-tokenize manuscript.txt
+    pystylometry-tokenize manuscript.txt --json --metadata
+    pystylometry-tokenize manuscript.txt --stats
+    bnc --input-file manuscript.txt
+    bnc --input-file manuscript.txt --output-file report.html --format html
+    bnc -i manuscript.txt --format json
 """
 
 from __future__ import annotations
@@ -423,5 +431,692 @@ The generated viewer includes:
     print()
 
 
+def tokenize_cli() -> None:
+    """CLI entry point for stylometric tokenization."""
+    parser = argparse.ArgumentParser(
+        prog="pystylometry-tokenize",
+        description="Tokenize text for stylometric analysis.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  pystylometry-tokenize manuscript.txt
+  pystylometry-tokenize manuscript.txt --json
+  pystylometry-tokenize manuscript.txt --json --metadata
+  pystylometry-tokenize manuscript.txt --stats
+  pystylometry-tokenize manuscript.txt -U --expand-contractions
+  pystylometry-tokenize manuscript.txt --min-length 3 --strip-numbers
+""",
+    )
+
+    parser.add_argument(
+        "file",
+        type=Path,
+        help="Path to text file to tokenize",
+    )
+
+    # Output mode
+    output_group = parser.add_argument_group("output")
+    output_group.add_argument(
+        "-j",
+        "--json",
+        action="store_true",
+        help="Output as JSON (list of strings, or list of objects with --metadata)",
+    )
+    output_group.add_argument(
+        "-m",
+        "--metadata",
+        action="store_true",
+        help="Include token type and position metadata (implies --json)",
+    )
+    output_group.add_argument(
+        "-s",
+        "--stats",
+        action="store_true",
+        help="Show tokenization statistics instead of tokens",
+    )
+
+    # Core behavior
+    behavior_group = parser.add_argument_group("behavior")
+    behavior_group.add_argument(
+        "-U",
+        "--no-lowercase",
+        action="store_true",
+        help="Preserve original case (default: lowercase)",
+    )
+    behavior_group.add_argument(
+        "-e",
+        "--expand-contractions",
+        action="store_true",
+        help="Expand contractions (it's -> it is)",
+    )
+    behavior_group.add_argument(
+        "-n",
+        "--strip-numbers",
+        action="store_true",
+        help="Remove numeric tokens",
+    )
+    behavior_group.add_argument(
+        "--keep-punctuation",
+        action="store_true",
+        help="Keep punctuation tokens (default: stripped)",
+    )
+
+    # Filtering
+    filter_group = parser.add_argument_group("filtering")
+    filter_group.add_argument(
+        "--min-length",
+        type=int,
+        default=1,
+        metavar="N",
+        help="Minimum token length (default: 1)",
+    )
+    filter_group.add_argument(
+        "--max-length",
+        type=int,
+        default=None,
+        metavar="N",
+        help="Maximum token length (default: unlimited)",
+    )
+    filter_group.add_argument(
+        "--preserve-urls",
+        action="store_true",
+        help="Keep URL tokens",
+    )
+    filter_group.add_argument(
+        "--preserve-emails",
+        action="store_true",
+        help="Keep email tokens",
+    )
+    filter_group.add_argument(
+        "--preserve-hashtags",
+        action="store_true",
+        help="Keep hashtag tokens",
+    )
+    filter_group.add_argument(
+        "--preserve-mentions",
+        action="store_true",
+        help="Keep @mention tokens",
+    )
+
+    # Advanced
+    advanced_group = parser.add_argument_group("advanced")
+    advanced_group.add_argument(
+        "--expand-abbreviations",
+        action="store_true",
+        help="Expand abbreviations (Dr. -> Doctor)",
+    )
+    advanced_group.add_argument(
+        "--strip-accents",
+        action="store_true",
+        help="Remove accents from characters",
+    )
+    advanced_group.add_argument(
+        "--no-clean",
+        action="store_true",
+        help="Skip text cleaning (italics, brackets, page markers)",
+    )
+    advanced_group.add_argument(
+        "--no-unicode-normalize",
+        action="store_true",
+        help="Skip unicode normalization",
+    )
+
+    args = parser.parse_args()
+
+    # --- ANSI colors ---
+    use_color = sys.stderr.isatty()
+
+    def _c(code: str, text: str) -> str:
+        return f"\033[{code}m{text}\033[0m" if use_color else text
+
+    bold = lambda t: _c("1", t)  # noqa: E731
+    dim = lambda t: _c("2", t)  # noqa: E731
+    cyan = lambda t: _c("36", t)  # noqa: E731
+    green = lambda t: _c("32", t)  # noqa: E731
+    yellow = lambda t: _c("33", t)  # noqa: E731
+
+    # --- Validate file ---
+    if not args.file.exists():
+        print(f"Error: File not found: {args.file}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        text = args.file.read_text(encoding="utf-8")
+    except Exception as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # --- Build Tokenizer kwargs ---
+    tokenizer_kwargs = {
+        "lowercase": not args.no_lowercase,
+        "min_length": args.min_length,
+        "max_length": args.max_length,
+        "strip_numbers": args.strip_numbers,
+        "strip_punctuation": not args.keep_punctuation,
+        "preserve_urls": args.preserve_urls,
+        "preserve_emails": args.preserve_emails,
+        "preserve_hashtags": args.preserve_hashtags,
+        "preserve_mentions": args.preserve_mentions,
+        "expand_contractions": args.expand_contractions,
+        "expand_abbreviations": args.expand_abbreviations,
+        "strip_accents": args.strip_accents,
+        "normalize_unicode": not args.no_unicode_normalize,
+        "clean_text": not args.no_clean,
+    }
+
+    # Collect active options for banner
+    active_opts = []
+    if args.no_lowercase:
+        active_opts.append("preserve case")
+    if args.expand_contractions:
+        active_opts.append("expand contractions")
+    if args.expand_abbreviations:
+        active_opts.append("expand abbreviations")
+    if args.strip_numbers:
+        active_opts.append("strip numbers")
+    if args.keep_punctuation:
+        active_opts.append("keep punctuation")
+    if args.strip_accents:
+        active_opts.append("strip accents")
+    if args.no_clean:
+        active_opts.append("skip cleaning")
+    if args.no_unicode_normalize:
+        active_opts.append("skip unicode normalization")
+    if args.preserve_urls:
+        active_opts.append("preserve URLs")
+    if args.preserve_emails:
+        active_opts.append("preserve emails")
+    if args.preserve_hashtags:
+        active_opts.append("preserve hashtags")
+    if args.preserve_mentions:
+        active_opts.append("preserve mentions")
+    if args.min_length > 1:
+        active_opts.append(f"min length {args.min_length}")
+    if args.max_length is not None:
+        active_opts.append(f"max length {args.max_length}")
+
+    # Determine output format
+    if args.stats:
+        output_format = "Statistics"
+    elif args.metadata:
+        output_format = "JSON (with metadata)"
+    elif args.json:
+        output_format = "JSON"
+    else:
+        output_format = "One token per line"
+
+    # --- Banner (to stderr so stdout stays pipeable) ---
+    char_count = len(text)
+    line_count = text.count("\n") + 1
+
+    banner = sys.stderr
+    print(file=banner)
+    print(f"  {bold('PYSTYLOMETRY')} {dim('—')} {cyan('Stylometric Tokenizer')}", file=banner)
+    print(f"  {dim('═' * 71)}", file=banner)
+    print(file=banner)
+    print(f"  {bold('INPUT')}", file=banner)
+    print(f"  {dim('─' * 71)}", file=banner)
+    print(f"    File:              {args.file}", file=banner)
+    print(f"    Size:              {char_count:,} characters / {line_count:,} lines", file=banner)
+    print(file=banner)
+    print(f"  {bold('CONFIGURATION')}", file=banner)
+    print(f"  {dim('─' * 71)}", file=banner)
+    print(f"    Case:              {'preserve' if args.no_lowercase else 'lowercase'}", file=banner)
+    print(
+        f"    Punctuation:       {'keep' if args.keep_punctuation else 'strip'}",
+        file=banner,
+    )
+    print(
+        f"    Contractions:      {'expand' if args.expand_contractions else 'preserve'}",
+        file=banner,
+    )
+    print(f"    Numbers:           {'strip' if args.strip_numbers else 'keep'}", file=banner)
+    if active_opts:
+        print(f"    Active options:    {', '.join(active_opts)}", file=banner)
+    print(file=banner)
+    print(f"  {bold('OUTPUT')}", file=banner)
+    print(f"  {dim('─' * 71)}", file=banner)
+    print(f"    Format:            {output_format}", file=banner)
+    print(file=banner)
+
+    # --- Tokenize ---
+    from pystylometry.tokenizer import Tokenizer
+
+    tokenizer = Tokenizer(**tokenizer_kwargs)
+
+    if args.stats:
+        stats = tokenizer.get_statistics(text)
+        print(f"  {bold('RESULTS')}", file=banner)
+        print(f"  {dim('─' * 71)}", file=banner)
+        print(f"    Total tokens:      {green(f'{stats.total_tokens:,}')}", file=banner)
+        print(f"    Unique tokens:     {green(f'{stats.unique_tokens:,}')}", file=banner)
+        print(f"    Word tokens:       {stats.word_tokens:,}", file=banner)
+        print(f"    Number tokens:     {stats.number_tokens:,}", file=banner)
+        print(f"    Punctuation:       {stats.punctuation_tokens:,}", file=banner)
+        print(f"    URLs:              {stats.url_tokens:,}", file=banner)
+        print(f"    Emails:            {stats.email_tokens:,}", file=banner)
+        print(f"    Hashtags:          {stats.hashtag_tokens:,}", file=banner)
+        print(f"    Mentions:          {stats.mention_tokens:,}", file=banner)
+        print(f"    Avg length:        {stats.average_token_length:.1f}", file=banner)
+        print(f"    Min length:        {stats.min_token_length}", file=banner)
+        print(f"    Max length:        {stats.max_token_length}", file=banner)
+        print(file=banner)
+
+        if args.json:
+            import dataclasses
+
+            print(json.dumps(dataclasses.asdict(stats), indent=2))
+
+    elif args.metadata or (args.json and args.metadata):
+        metadata_list = tokenizer.tokenize_with_metadata(text)
+        count = len(metadata_list)
+        print(
+            f"  {yellow('Tokenizing...')} {green(f'{count:,}')} tokens extracted",
+            file=banner,
+        )
+        print(file=banner)
+        output = [
+            {
+                "token": m.token,
+                "start": m.start,
+                "end": m.end,
+                "type": m.token_type,
+            }
+            for m in metadata_list
+        ]
+        print(json.dumps(output, indent=2))
+
+    elif args.json:
+        tokens = tokenizer.tokenize(text)
+        count = len(tokens)
+        print(
+            f"  {yellow('Tokenizing...')} {green(f'{count:,}')} tokens extracted",
+            file=banner,
+        )
+        print(file=banner)
+        print(json.dumps(tokens, indent=2))
+
+    else:
+        tokens = tokenizer.tokenize(text)
+        count = len(tokens)
+        print(
+            f"  {yellow('Tokenizing...')} {green(f'{count:,}')} tokens extracted",
+            file=banner,
+        )
+        print(file=banner)
+        for token in tokens:
+            print(token)
+
+
+def bnc_frequency_cli() -> None:
+    """CLI entry point for BNC word frequency analysis."""
+    parser = argparse.ArgumentParser(
+        prog="bnc",
+        description="Analyze word frequencies against the British National Corpus (BNC).",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  bnc --input-file manuscript.txt
+  bnc --input-file manuscript.txt --output-file report.html
+  bnc --input-file manuscript.txt --format json
+  bnc --input-file manuscript.txt --overuse-threshold 2.0 --min-mentions 3
+  bnc --input-file manuscript.txt --no-wordnet
+
+Output:
+  Generates a report with three sections:
+  - Not in BNC: Words not found in the corpus (with WordNet status, character type)
+  - Most Underused: Words appearing less frequently than expected
+  - Most Overused: Words appearing more frequently than expected
+
+Thresholds:
+  Words with ratio > overuse-threshold are "overused"
+  Words with ratio < underuse-threshold are "underused"
+  Ratio = observed_count / expected_count (based on BNC frequencies)
+""",
+    )
+
+    parser.add_argument(
+        "--input-file",
+        "-i",
+        type=Path,
+        required=True,
+        metavar="FILE",
+        help="Path to text file to analyze",
+    )
+    parser.add_argument(
+        "--output-file",
+        "-o",
+        type=Path,
+        default=None,
+        metavar="FILE",
+        help="Output file (default: <input>_bnc_frequency.<ext> based on --format)",
+    )
+    parser.add_argument(
+        "--overuse-threshold",
+        type=float,
+        default=1.3,
+        metavar="N",
+        help="Ratio above which words are considered overused (default: 1.3)",
+    )
+    parser.add_argument(
+        "--underuse-threshold",
+        type=float,
+        default=0.8,
+        metavar="N",
+        help="Ratio below which words are considered underused (default: 0.8)",
+    )
+    parser.add_argument(
+        "--min-mentions",
+        type=int,
+        default=1,
+        metavar="N",
+        help="Minimum word occurrences to include (default: 1)",
+    )
+    parser.add_argument(
+        "--no-wordnet",
+        action="store_true",
+        help="Skip WordNet lookup for unknown words",
+    )
+    parser.add_argument(
+        "--format",
+        choices=["csv", "html", "json", "excel"],
+        default="csv",
+        help="Output format: csv (tab-delimited), html (interactive), json, excel (default: csv)",
+    )
+
+    args = parser.parse_args()
+
+    # Import rich for colored output
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.text import Text
+
+    console = Console(stderr=True)
+
+    # Validate file exists
+    if not args.input_file.exists():
+        console.print(f"[red]Error:[/red] File not found: {args.input_file}")
+        sys.exit(1)
+
+    # Read file
+    try:
+        text = args.input_file.read_text(encoding="utf-8")
+    except Exception as e:
+        console.print(f"[red]Error reading file:[/red] {e}")
+        sys.exit(1)
+
+    # Determine output path (extension based on format)
+    suffix_map = {"csv": ".tsv", "html": ".html", "json": ".json", "excel": ".xlsx"}
+    if args.output_file:
+        output_path = args.output_file
+    else:
+        suffix = suffix_map[args.format]
+        output_path = args.input_file.with_name(f"{args.input_file.stem}_bnc_frequency{suffix}")
+
+    # Calculate file stats
+    token_count = len(text.split())
+    char_count = len(text)
+
+    # Print header
+    console.print()
+    header = Text()
+    header.append("PYSTYLOMETRY", style="bold cyan")
+    header.append(" — ", style="dim")
+    header.append("BNC Word Frequency Analysis", style="bold white")
+    console.print(Panel(header, border_style="cyan"))
+
+    # Input section
+    console.print()
+    console.print("[bold]INPUT[/bold]", style="cyan")
+    console.print("─" * 60, style="dim")
+    console.print(f"  File:    [white]{args.input_file}[/white]")
+    console.print(
+        f"  Size:    [green]{char_count:,}[/green] chars / [green]{token_count:,}[/green] tokens"
+    )
+
+    # Parameters section
+    console.print()
+    console.print("[bold]PARAMETERS[/bold]", style="cyan")
+    console.print("─" * 60, style="dim")
+    console.print(f"  Overuse threshold:   [yellow]{args.overuse_threshold}x[/yellow]")
+    console.print(f"  Underuse threshold:  [yellow]{args.underuse_threshold}x[/yellow]")
+    console.print(f"  Min mentions:        [yellow]{args.min_mentions}[/yellow]")
+    console.print(f"  WordNet lookup:      [yellow]{'no' if args.no_wordnet else 'yes'}[/yellow]")
+
+    # Output section
+    console.print()
+    console.print("[bold]OUTPUT[/bold]", style="cyan")
+    console.print("─" * 60, style="dim")
+    fmt_display = {
+        "csv": "Tab-delimited CSV",
+        "html": "Interactive HTML",
+        "json": "JSON",
+        "excel": "Excel (.xlsx)",
+    }
+    console.print(f"  Format:      [magenta]{fmt_display[args.format]}[/magenta]")
+    console.print(f"  Destination: [white]{output_path}[/white]")
+
+    # Run analysis with spinner
+    console.print()
+    with console.status("[bold cyan]Running analysis...[/bold cyan]", spinner="dots"):
+        from pystylometry.lexical.bnc_frequency import compute_bnc_frequency
+
+        result = compute_bnc_frequency(
+            text,
+            overuse_threshold=args.overuse_threshold,
+            underuse_threshold=args.underuse_threshold,
+            include_wordnet=not args.no_wordnet,
+            min_mentions=args.min_mentions,
+        )
+
+    # Output results
+    if args.format == "json":
+        output = {
+            "stats": {
+                "total_tokens": result.total_tokens,
+                "unique_tokens": result.unique_tokens,
+                "overused_count": len(result.overused),
+                "underused_count": len(result.underused),
+                "not_in_bnc_count": len(result.not_in_bnc),
+            },
+            "overused": [
+                {
+                    "word": w.word,
+                    "observed": w.observed,
+                    "expected": w.expected,
+                    "ratio": w.ratio,
+                    "char_type": w.char_type,
+                }
+                for w in result.overused
+            ],
+            "underused": [
+                {
+                    "word": w.word,
+                    "observed": w.observed,
+                    "expected": w.expected,
+                    "ratio": w.ratio,
+                    "char_type": w.char_type,
+                }
+                for w in result.underused
+            ],
+            "not_in_bnc": [
+                {
+                    "word": w.word,
+                    "observed": w.observed,
+                    "in_wordnet": w.in_wordnet,
+                    "char_type": w.char_type,
+                }
+                for w in result.not_in_bnc
+            ],
+        }
+        output_path.write_text(json.dumps(output, indent=2))
+        console.print(f'[green]✓[/green] JSON saved to: [white]"{output_path}"[/white]')
+
+    elif args.format == "csv":
+        # Tab-delimited output with category column
+        lines = ["category\tword\tobserved\texpected\tratio\tin_wordnet\tchar_type"]
+
+        def fmt_wordnet(val: bool | None) -> str:
+            if val is True:
+                return "yes"
+            elif val is False:
+                return "no"
+            return ""
+
+        for w in result.overused:
+            expected = f"{w.expected:.2f}" if w.expected else ""
+            ratio = f"{w.ratio:.4f}" if w.ratio else ""
+            in_wn = fmt_wordnet(w.in_wordnet)
+            lines.append(
+                f"overused\t{w.word}\t{w.observed}\t{expected}\t{ratio}\t{in_wn}\t{w.char_type}"
+            )
+
+        for w in result.underused:
+            expected = f"{w.expected:.2f}" if w.expected else ""
+            ratio = f"{w.ratio:.4f}" if w.ratio else ""
+            in_wn = fmt_wordnet(w.in_wordnet)
+            lines.append(
+                f"underused\t{w.word}\t{w.observed}\t{expected}\t{ratio}\t{in_wn}\t{w.char_type}"
+            )
+
+        for w in result.not_in_bnc:
+            in_wn = fmt_wordnet(w.in_wordnet)
+            lines.append(f"not-in-bnc\t{w.word}\t{w.observed}\t\t\t{in_wn}\t{w.char_type}")
+
+        output_path.write_text("\n".join(lines))
+        console.print(f'[green]✓[/green] TSV saved to: [white]"{output_path}"[/white]')
+
+    elif args.format == "excel":
+        try:
+            from openpyxl import Workbook  # type: ignore[import-untyped]
+            from openpyxl.styles import Alignment, PatternFill  # type: ignore[import-untyped]
+        except ImportError:
+            console.print("[red]Error:[/red] Excel export requires openpyxl.")
+            console.print("  Install with: [yellow]pip install pystylometry[excel][/yellow]")
+            console.print("  Or for pipx: [yellow]pipx inject pystylometry openpyxl[/yellow]")
+            sys.exit(1)
+
+        wb = Workbook()
+
+        # Remove default sheet
+        wb.remove(wb.active)
+
+        # Cell style: width 15, centered, vertically centered
+        align = Alignment(horizontal="center", vertical="center")
+
+        def fmt_wordnet_excel(val: bool | None) -> str:
+            if val is True:
+                return "yes"
+            elif val is False:
+                return "no"
+            return ""
+
+        # Overused sheet (sorted by ratio, high to low)
+        ws_over = wb.create_sheet("overused")
+        ws_over.append(["word", "observed", "expected", "ratio", "in_wordnet", "char_type"])
+        for w in sorted(result.overused, key=lambda x: x.ratio or 0, reverse=True):
+            in_wn = fmt_wordnet_excel(w.in_wordnet)
+            ws_over.append([w.word, w.observed, w.expected, w.ratio, in_wn, w.char_type])
+
+        # Underused sheet (sorted by ratio, high to low)
+        ws_under = wb.create_sheet("underused")
+        ws_under.append(["word", "observed", "expected", "ratio", "in_wordnet", "char_type"])
+        for w in sorted(result.underused, key=lambda x: x.ratio or 0, reverse=True):
+            in_wn = fmt_wordnet_excel(w.in_wordnet)
+            ws_under.append([w.word, w.observed, w.expected, w.ratio, in_wn, w.char_type])
+
+        # Not in BNC sheet
+        ws_notbnc = wb.create_sheet("not-in-bnc")
+        ws_notbnc.append(["word", "observed", "in_wordnet", "char_type", "plural_form"])
+        for w in result.not_in_bnc:
+            in_wn = fmt_wordnet_excel(w.in_wordnet)
+            plural = "yes" if w.word.endswith("s") else "no"
+            ws_notbnc.append([w.word, w.observed, in_wn, w.char_type, plural])
+
+        # Apply formatting to all sheets
+        for ws in [ws_over, ws_under, ws_notbnc]:
+            for col in ws.columns:
+                col_letter = col[0].column_letter
+                # Word column (A) gets width 30, others get 15
+                ws.column_dimensions[col_letter].width = 30 if col_letter == "A" else 15
+            for row in ws.iter_rows():
+                for cell in row:
+                    cell.alignment = align
+
+        # Apply number formatting to expected (C) and ratio (D) columns
+        for ws in [ws_over, ws_under]:
+            for row in range(2, ws.max_row + 1):  # Skip header row
+                ws[f"C{row}"].number_format = "0.00"
+                ws[f"D{row}"].number_format = "0.00"
+
+        # Apply background colors to in_wordnet column
+        fill_yes = PatternFill(start_color="C6EFCE", end_color="C6EFCE", fill_type="solid")
+        fill_no = PatternFill(start_color="FFC7CE", end_color="FFC7CE", fill_type="solid")
+
+        # in_wordnet is column E for overused/underused, column C for not-in-bnc
+        for ws in [ws_over, ws_under]:
+            for row in range(2, ws.max_row + 1):
+                cell = ws[f"E{row}"]
+                if cell.value == "yes":
+                    cell.fill = fill_yes
+                elif cell.value == "no":
+                    cell.fill = fill_no
+
+        for row in range(2, ws_notbnc.max_row + 1):
+            cell = ws_notbnc[f"C{row}"]
+            if cell.value == "yes":
+                cell.fill = fill_yes
+            elif cell.value == "no":
+                cell.fill = fill_no
+
+        # Apply background colors to plural_form column (E) in not-in-bnc
+        fill_plural_yes = PatternFill(
+            start_color="BDD7EE", end_color="BDD7EE", fill_type="solid"
+        )  # Light blue
+        fill_plural_no = PatternFill(
+            start_color="FCE4D6", end_color="FCE4D6", fill_type="solid"
+        )  # Light peach
+        for row in range(2, ws_notbnc.max_row + 1):
+            cell = ws_notbnc[f"E{row}"]
+            if cell.value == "yes":
+                cell.fill = fill_plural_yes
+            elif cell.value == "no":
+                cell.fill = fill_plural_no
+
+        wb.save(output_path)
+        console.print(f'[green]✓[/green] Excel saved to: [white]"{output_path}"[/white]')
+
+    else:  # html
+        from pystylometry.viz.jsx import export_bnc_frequency_jsx
+
+        export_bnc_frequency_jsx(
+            result,
+            output_file=output_path,
+            title=f"BNC Frequency Analysis: {args.input_file.name}",
+            source_file=str(args.input_file),
+        )
+
+        abs_path = output_path.resolve()
+        file_url = f"file://{abs_path}"
+        console.print(f'[green]✓[/green] HTML report saved to: [white]"{output_path}"[/white]')
+        console.print(f"  Open in browser: [link={file_url}]{file_url}[/link]")
+
+    # Summary table
+    console.print()
+    table = Table(title="Summary", border_style="cyan", header_style="bold cyan")
+    table.add_column("Metric", style="white")
+    table.add_column("Count", justify="right", style="green")
+
+    table.add_row("Total tokens", f"{result.total_tokens:,}")
+    table.add_row("Unique words", f"{result.unique_tokens:,}")
+    table.add_row("Not in BNC", f"[dim]{len(result.not_in_bnc):,}[/dim]")
+    table.add_row("Underused", f"[blue]{len(result.underused):,}[/blue]")
+    table.add_row("Overused", f"[red]{len(result.overused):,}[/red]")
+
+    console.print(table)
+    console.print()
+
+
 if __name__ == "__main__":
     drift_cli()