cli.py

#!/usr/bin/env python3
"""
Booksmith - Unified Command-Line Interface

A high-quality tool for adapting EPUB content using LLMs. This CLI provides
subcommands for editing, profiling, validation, analysis, planning, checking,
cost estimation, and annotating EPUB files.

Usage:
    python cli.py <command> [options]

Commands:
    edit      - Core editing (wraps epub_cleaner.py)
    profile   - Build author profile (wraps style_profiler.py)
    validate  - Check style drift (wraps style_validator.py)
    analyze   - Extract book model (wraps book_analyzer.py)
    plan      - Plan changes (wraps change_planner.py)
    check     - Verify consistency (wraps consistency_checker.py)
    estimate  - Estimate API costs before processing
    annotate  - Add commentary (wraps annotator.py + footnote_inserter.py)

Examples:
    python cli.py edit --input book.epub --output clean.epub
    python cli.py profile --input *.epub --output author.json
    python cli.py validate --original original.txt --modified modified.txt
    python cli.py analyze --input book.epub --output model.json
    python cli.py estimate --input book.epub --workflow transform
    python cli.py annotate --input book.epub --config commentary.yaml --output annotated.epub
    python cli.py --workflow cleanup --input book.epub

For help on a specific command:
    python cli.py <command> --help
"""

import argparse
import glob
import os
import sys
from pathlib import Path
from typing import Optional

try:
    import yaml
except ImportError:
    yaml = None


# ---------- VERSION ----------
__version__ = "0.1.0"


# ---------- WORKFLOW LOADING ----------

def find_workflow_file(workflow_name: str) -> Optional[Path]:
    """
    Find a workflow configuration file by name.

    Searches in:
    1. ./workflows/<name>.yaml
    2. ./workflows/<name>.yml
    3. <script_dir>/workflows/<name>.yaml
    4. <script_dir>/workflows/<name>.yml
    """
    script_dir = Path(__file__).parent

    search_paths = [
        Path("workflows") / f"{workflow_name}.yaml",
        Path("workflows") / f"{workflow_name}.yml",
        script_dir / "workflows" / f"{workflow_name}.yaml",
        script_dir / "workflows" / f"{workflow_name}.yml",
    ]

    for path in search_paths:
        if path.exists():
            return path

    return None


def load_workflow(workflow_name: str) -> dict:
    """
    Load a workflow configuration from YAML file.

    Returns a dict with configuration overrides for the subcommand.
    """
    if yaml is None:
        print("Error: PyYAML not installed. Run: pip install pyyaml")
        sys.exit(1)

    workflow_path = find_workflow_file(workflow_name)

    if workflow_path is None:
        # List available workflows
        script_dir = Path(__file__).parent
        available = []

        for search_dir in [Path("workflows"), script_dir / "workflows"]:
            if search_dir.exists():
                for f in search_dir.glob("*.yaml"):
                    available.append(f.stem)
                for f in search_dir.glob("*.yml"):
                    available.append(f.stem)

        available = sorted(set(available))

        print(f"Error: Workflow not found: {workflow_name}")
        if available:
            print(f"Available workflows: {', '.join(available)}")
        else:
            print("No workflows found in ./workflows/ directory.")
            print("Create workflow files (e.g., workflows/cleanup.yaml) to use --workflow.")
        sys.exit(1)

    try:
        with open(workflow_path, 'r', encoding='utf-8') as f:
            workflow = yaml.safe_load(f) or {}
        print(f"Loaded workflow: {workflow_name} (from {workflow_path})")
        return workflow
    except yaml.YAMLError as e:
        print(f"Error parsing workflow file: {e}")
        sys.exit(1)


# ---------- SUBCOMMAND: edit ----------

def setup_edit_parser(subparsers) -> None:
    """Set up the 'edit' subcommand parser."""
    parser = subparsers.add_parser(
        'edit',
        help='Core editing - selectively rewrite paragraphs using LLM analysis',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description="""
Edit EPUB content using LLM-based analysis and selective rewriting.

This command sends full chapters for context, but only rewrites problematic
paragraphs - providing both accuracy and efficiency.
        """,
        epilog="""
Examples:
  %(prog)s --input book.epub --output book_cleaned.epub
  %(prog)s --input book.epub --dry-run
  %(prog)s --input book.epub --config my_config.yaml --prompts my_prompts.yaml
  %(prog)s --input book.epub --output clean.epub --verbose

Environment variables:
  ANTHROPIC_API_KEY    Your Anthropic API key (required for Claude)
        """
    )

    parser.add_argument(
        '--input', '-i',
        required=True,
        help='Input EPUB file path'
    )
    parser.add_argument(
        '--output', '-o',
        help='Output EPUB file path (default: input_cleaned.epub)'
    )
    parser.add_argument(
        '--config', '-c',
        help='Path to config.yaml file (default: ./config.yaml)'
    )
    parser.add_argument(
        '--prompts', '-p',
        help='Path to prompts.yaml file (default: ./prompts.yaml)'
    )
    parser.add_argument(
        '--dry-run', '-n',
        action='store_true',
        help='Analyze and report changes without modifying files'
    )


def run_edit(args, verbose: bool = False) -> int:
    """Run the edit subcommand."""
    try:
        from epub_cleaner import main as epub_cleaner_main, load_config, load_prompts, create_client, process_epub
    except ImportError:
        print("Error: Could not import epub_cleaner module")
        print("Make sure epub_cleaner.py is in the same directory")
        return 1

    # Validate input file
    input_path = Path(args.input)
    if not input_path.exists():
        print(f"Error: Input file not found: {args.input}")
        return 1

    if not input_path.suffix.lower() == '.epub':
        print(f"Warning: Input file does not have .epub extension: {args.input}")

    # Determine output path
    if args.output:
        output_path = args.output
    else:
        output_path = str(input_path.with_stem(input_path.stem + '_cleaned'))

    # Load configuration and prompts
    config = load_config(args.config)
    prompts = load_prompts(args.prompts)

    # Create LLM client
    client = create_client(config)

    # Process the EPUB
    process_epub(
        input_path=str(input_path),
        output_path=output_path,
        config=config,
        prompts=prompts,
        client=client,
        dry_run=args.dry_run
    )

    return 0


# ---------- SUBCOMMAND: profile ----------

def setup_profile_parser(subparsers) -> None:
    """Set up the 'profile' subcommand parser."""
    parser = subparsers.add_parser(
        'profile',
        help='Build author profile - analyze EPUBs to create style profiles',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description="""
Analyze one or more EPUB files to create a comprehensive author style profile
using Claude for deep literary analysis.

The profile includes:
- Overall writing style description
- Character voice patterns
- Thematic elements
- Do/avoid guidelines for style preservation
        """,
        epilog="""
Examples:
  %(prog)s --input book.epub --output profile.json
  %(prog)s --input book1.epub book2.epub book3.epub --output author_profile.json
  %(prog)s --input "author_works/*.epub" --output tolkien_profile.json
  %(prog)s --input book.epub --model claude-sonnet-4-20250514 --output profile.json

Environment variables:
  ANTHROPIC_API_KEY    Your Anthropic API key (required)
        """
    )

    parser.add_argument(
        '--input', '-i',
        nargs='+',
        required=True,
        help='Input EPUB file(s). Supports multiple files and glob patterns.'
    )
    parser.add_argument(
        '--output', '-o',
        default='author_profile.json',
        help='Output JSON profile path (default: author_profile.json)'
    )
    parser.add_argument(
        '--model', '-m',
        default='claude-sonnet-4-20250514',
        help='Claude model to use (default: claude-sonnet-4-20250514)'
    )


def run_profile(args, verbose: bool = False) -> int:
    """Run the profile subcommand."""
    try:
        from style_profiler import create_client, generate_style_profile
        import json
    except ImportError:
        print("Error: Could not import style_profiler module")
        print("Make sure style_profiler.py is in the same directory")
        return 1

    # Expand glob patterns and collect all EPUB files
    epub_files = []
    for pattern in args.input:
        if '*' in pattern or '?' in pattern:
            matches = glob.glob(pattern, recursive=True)
            epub_files.extend([f for f in matches if f.lower().endswith('.epub')])
        else:
            if Path(pattern).exists():
                epub_files.append(pattern)
            else:
                print(f"Warning: File not found: {pattern}")

    # Remove duplicates while preserving order
    seen = set()
    epub_files = [f for f in epub_files if not (f in seen or seen.add(f))]

    if not epub_files:
        print("Error: No valid EPUB files found")
        return 1

    # Create client
    client = create_client()

    # Generate profile
    profile = generate_style_profile(
        client=client,
        model=args.model,
        epub_paths=epub_files,
        verbose=verbose
    )

    # Save profile
    output_path = Path(args.output)
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(profile, f, indent=2, ensure_ascii=False)

    print(f"\nProfile saved to: {output_path.absolute()}")
    return 0


# ---------- SUBCOMMAND: validate ----------

def setup_validate_parser(subparsers) -> None:
    """Set up the 'validate' subcommand parser."""
    parser = subparsers.add_parser(
        'validate',
        help='Check style drift - compare original vs modified text',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description="""
Compare original text vs modified text and use an LLM to measure style drift.

This tool rates stylistic similarity (0-100 score), explains what drifted
(sentence length, tone, vocabulary, etc.), and can compare against an
author profile if provided.
        """,
        epilog="""
Examples:
  %(prog)s --original original.txt --modified modified.txt
  %(prog)s --original original.txt --modified modified.txt --profile author.json
  %(prog)s --original original.txt --modified modified.txt --output report.json

Score interpretation:
  90-100: Excellent - Style nearly perfectly preserved
  75-89:  Good - Minor stylistic differences
  50-74:  Moderate - Noticeable drift in some areas
  25-49:  Poor - Significant style changes
  0-24:   Severe - Almost entirely different style

Environment variables:
  ANTHROPIC_API_KEY    Your Anthropic API key (required)
        """
    )

    parser.add_argument(
        '--original', '-o',
        required=True,
        help='Path to the original text file'
    )
    parser.add_argument(
        '--modified', '-m',
        required=True,
        help='Path to the modified text file'
    )
    parser.add_argument(
        '--profile', '-p',
        help='Optional path to author profile JSON file for additional comparison'
    )
    parser.add_argument(
        '--output',
        help='Path to save JSON output (default: print to console)'
    )
    parser.add_argument(
        '--model',
        default='claude-sonnet-4-5-20250929',
        help='Anthropic model to use (default: claude-sonnet-4-5-20250929)'
    )
    parser.add_argument(
        '--json',
        action='store_true',
        help='Output only JSON (no formatted output)'
    )


def run_validate(args, verbose: bool = False) -> int:
    """Run the validate subcommand."""
    try:
        from style_validator import (
            validate_style, load_text_file, load_author_profile,
            result_to_dict, print_result
        )
        import json
    except ImportError:
        print("Error: Could not import style_validator module")
        print("Make sure style_validator.py is in the same directory")
        return 1

    # Load files
    original_text = load_text_file(args.original)
    modified_text = load_text_file(args.modified)

    # Load profile if provided
    profile = None
    if args.profile:
        profile = load_author_profile(args.profile)

    # Run validation
    result = validate_style(
        original_text=original_text,
        modified_text=modified_text,
        profile=profile,
        model=args.model,
        verbose=verbose
    )

    # Output results
    result_dict = result_to_dict(result)

    if args.output:
        with open(args.output, 'w', encoding='utf-8') as f:
            json.dump(result_dict, f, indent=2, ensure_ascii=False)
        print(f"Results saved to: {args.output}")
        if not args.json:
            print_result(result)
    elif args.json:
        print(json.dumps(result_dict, indent=2, ensure_ascii=False))
    else:
        print_result(result)

    # Exit with non-zero if severe drift
    if result.overall_score < 25:
        return 2
    elif result.overall_score < 50:
        return 1
    return 0


# ---------- SUBCOMMAND: analyze ----------

def setup_analyze_parser(subparsers) -> None:
    """Set up the 'analyze' subcommand parser."""
    parser = subparsers.add_parser(
        'analyze',
        help='Extract book model - characters, plot, timeline, relationships',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description="""
Extract a structured book model from EPUB using LLM analysis.

The book model includes:
- Characters (names, descriptions, relationships)
- Locations (names, descriptions, significance)
- Timeline (chapter-by-chapter events)
- Plot structure (setup, rising action, climax, resolution)
- Themes and narrative notes
        """,
        epilog="""
Examples:
  %(prog)s --input book.epub --output book_model.json
  %(prog)s --input book.epub --model claude-sonnet-4-5-20250929
  %(prog)s --input book.epub -v

Environment variables:
  ANTHROPIC_API_KEY    Your Anthropic API key (required)
        """
    )

    parser.add_argument(
        '--input', '-i',
        required=True,
        help='Input EPUB file path'
    )
    parser.add_argument(
        '--output', '-o',
        help='Output JSON file path (default: book_model.json)'
    )
    parser.add_argument(
        '--model', '-m',
        default='claude-sonnet-4-5-20250929',
        help='Claude model to use (default: claude-sonnet-4-5-20250929)'
    )
    parser.add_argument(
        '--rate-limit-delay',
        type=float,
        default=0.5,
        help='Delay between API calls in seconds (default: 0.5)'
    )


def run_analyze(args, verbose: bool = False) -> int:
    """Run the analyze subcommand."""
    try:
        from book_analyzer import analyze_book
    except ImportError:
        print("Error: Could not import book_analyzer module")
        print("Make sure book_analyzer.py is in the same directory")
        return 1

    # Validate input file
    input_path = Path(args.input)
    if not input_path.exists():
        print(f"Error: Input file not found: {args.input}")
        return 1

    # Determine output path
    if args.output:
        output_path = args.output
    else:
        output_path = str(input_path.with_suffix('.book_model.json'))

    # Run analysis
    analyze_book(
        input_path=str(input_path),
        output_path=output_path,
        model=args.model,
        rate_limit_delay=args.rate_limit_delay,
        verbose=verbose
    )

    return 0


# ---------- SUBCOMMAND: plan ----------

def setup_plan_parser(subparsers) -> None:
    """Set up the 'plan' subcommand parser."""
    parser = subparsers.add_parser(
        'plan',
        help='Plan changes - generate modification plans with ripple effect mapping',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description="""
Generate a change plan for modifying a book based on user goals.

Takes a book model and user's change request, then:
- Interprets user intent
- Identifies affected chapters/passages
- Maps ripple effects
- Generates a structured change plan

NOTE: This module is not yet implemented.
        """,
        epilog="""
Examples:
  %(prog)s --model book_model.json --goal "Convert to steampunk setting" --output plan.json
  %(prog)s --model book_model.json --goal "Remove character X" --output plan.json
        """
    )

    parser.add_argument(
        '--model', '-m',
        required=True,
        help='Path to book_model.json file'
    )
    parser.add_argument(
        '--goal', '-g',
        required=True,
        help='Description of the desired changes'
    )
    parser.add_argument(
        '--output', '-o',
        default='change_plan.json',
        help='Output change plan JSON file (default: change_plan.json)'
    )


def run_plan(args, verbose: bool = False) -> int:
    """Run the plan subcommand."""
    print("Error: change_planner module is not yet implemented.")
    print("This feature is planned for a future release.")
    print("")
    print("The change planner will:")
    print("  - Take a book model and user's change request")
    print("  - Identify affected chapters/passages")
    print("  - Map ripple effects across the narrative")
    print("  - Generate a structured change plan")
    return 1


# ---------- SUBCOMMAND: check ----------

def setup_check_parser(subparsers) -> None:
    """Set up the 'check' subcommand parser."""
    parser = subparsers.add_parser(
        'check',
        help='Verify consistency - cross-chapter validation for contradictions',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description="""
Check a modified EPUB for internal consistency and contradictions.

This tool validates:
- Character consistency (names, traits, relationships)
- Timeline coherence
- Location consistency
- Plot logic

NOTE: This module is not yet implemented.
        """,
        epilog="""
Examples:
  %(prog)s --input modified.epub --model book_model.json --output report.json
  %(prog)s --input modified.epub --original original.epub --output report.json
        """
    )

    parser.add_argument(
        '--input', '-i',
        required=True,
        help='Input EPUB file to check'
    )
    parser.add_argument(
        '--model', '-m',
        help='Path to book_model.json file for reference'
    )
    parser.add_argument(
        '--original', '-o',
        help='Path to original EPUB for comparison'
    )
    parser.add_argument(
        '--output',
        default='consistency_report.json',
        help='Output report JSON file (default: consistency_report.json)'
    )


def run_check(args, verbose: bool = False) -> int:
    """Run the check subcommand."""
    print("Error: consistency_checker module is not yet implemented.")
    print("This feature is planned for a future release.")
    print("")
    print("The consistency checker will:")
    print("  - Validate character consistency across chapters")
    print("  - Check timeline coherence")
    print("  - Detect contradictions introduced by edits")
    print("  - Generate a detailed validation report")
    return 1


# ---------- SUBCOMMAND: estimate ----------

def setup_estimate_parser(subparsers) -> None:
    """Set up the 'estimate' subcommand parser."""
    parser = subparsers.add_parser(
        'estimate',
        help='Estimate API costs - preview costs before processing',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description="""
Estimate API costs before processing an EPUB.

Analyzes the EPUB to count tokens and chapters, then calculates
estimated costs based on:
- Selected model (Haiku/Sonnet/Opus)
- Workflow type (cleanup/filter/transform/etc.)
- Optional features (profiling, analysis, drift validation)

Use this to budget before running expensive operations.
        """,
        epilog="""
Examples:
  %(prog)s --input book.epub
  %(prog)s --input book.epub --model opus --workflow transform
  %(prog)s --input book.epub --all-features
  %(prog)s --input book.epub --json

Model pricing (per million tokens, approximate):
  Haiku:  $0.80 input / $4 output
  Sonnet: $3 input / $15 output
  Opus:   $15 input / $75 output
        """
    )

    parser.add_argument(
        '--input', '-i',
        required=True,
        help='Input EPUB file path'
    )
    parser.add_argument(
        '--model', '-m',
        default='sonnet',
        choices=['haiku', 'sonnet', 'opus'],
        help='Model to estimate for (default: sonnet)'
    )
    parser.add_argument(
        '--workflow', '-w',
        default='cleanup',
        choices=['cleanup', 'filter', 'modernize', 'transform', 'annotate'],
        help='Workflow type (default: cleanup)'
    )
    parser.add_argument(
        '--with-profile',
        action='store_true',
        help='Include style profiling cost'
    )
    parser.add_argument(
        '--with-analysis',
        action='store_true',
        help='Include book analysis cost'
    )
    parser.add_argument(
        '--with-plan',
        action='store_true',
        help='Include change planning cost'
    )
    parser.add_argument(
        '--with-consistency',
        action='store_true',
        help='Include consistency checking cost'
    )
    parser.add_argument(
        '--with-drift',
        action='store_true',
        help='Include drift validation cost'
    )
    parser.add_argument(
        '--all-features',
        action='store_true',
        help='Include all optional features in estimate'
    )
    parser.add_argument(
        '--json',
        action='store_true',
        help='Output as JSON (no formatted output)'
    )


def run_estimate(args, verbose: bool = False) -> int:
    """Run the estimate subcommand."""
    try:
        from cost_estimator import estimate_cost
        import json
    except ImportError:
        print("Error: Could not import cost_estimator module")
        print("Make sure cost_estimator.py is in the same directory")
        return 1

    # Validate input file
    input_path = Path(args.input)
    if not input_path.exists():
        print(f"Error: Input file not found: {args.input}")
        return 1

    # Handle --all-features
    if args.all_features:
        args.with_profile = True
        args.with_analysis = True
        args.with_plan = True
        args.with_consistency = True
        args.with_drift = True

    # Run estimation
    result = estimate_cost(
        epub_path=str(input_path),
        model=args.model,
        workflow=args.workflow,
        with_profile=args.with_profile,
        with_book_analysis=args.with_analysis,
        with_change_plan=args.with_plan,
        with_consistency_check=args.with_consistency,
        with_drift_validation=args.with_drift,
        verbose=not args.json
    )

    if args.json:
        print(json.dumps(result, indent=2))

    return 0


# ---------- SUBCOMMAND: annotate ----------

def setup_annotate_parser(subparsers) -> None:
    """Set up the 'annotate' subcommand parser."""
    parser = subparsers.add_parser(
        'annotate',
        help='Add commentary - generate footnotes/endnotes in various styles',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description="""
Generate and insert annotations/commentary into an EPUB.

This command combines the annotator (generate commentary) and footnote_inserter
(insert into EPUB) functionality.

Commentary styles:
  - scholarly: Literary analysis, sources, references
  - historical: Period context, author biography, events
  - educational: Vocabulary, concepts, explanations
  - devils_advocate: Challenge assumptions, alternative views
  - thematic: Connections to other works, parallels
  - personal_lens: User-specified perspective
  - fun_facts: Trivia, behind-the-scenes, inspirations
  - funny: Humorous observations, witty asides
  - cross_reference: Links to other texts, author's other works
        """,
        epilog="""
Examples:
  %(prog)s --input book.epub --config commentary.yaml --output annotated.epub
  %(prog)s --input book.epub --style scholarly,funny --format footnotes --output annotated.epub
  %(prog)s --input book.epub --config commentary.yaml --dry-run

Config file structure (commentary.yaml):
  styles: [scholarly, funny]
  frequency: "2-4 per chapter"
  focus_areas: [character motivation, historical context]
  avoid: [spoilers]

Environment variables:
  ANTHROPIC_API_KEY    Your Anthropic API key (required)
        """
    )

    parser.add_argument(
        '--input', '-i',
        required=True,
        help='Input EPUB file path'
    )
    parser.add_argument(
        '--output', '-o',
        help='Output EPUB file path (default: input_annotated.epub)'
    )
    parser.add_argument(
        '--config', '-c',
        help='Path to commentary config YAML file'
    )
    parser.add_argument(
        '--style', '-s',
        help='Comma-separated commentary styles (e.g., scholarly,funny)'
    )
    parser.add_argument(
        '--format', '-f',
        choices=['footnotes', 'endnotes'],
        default='footnotes',
        help='Note placement: footnotes (end of chapter) or endnotes (end of book)'
    )
    parser.add_argument(
        '--frequency',
        default='2-4 per chapter',
        help='Annotation frequency (e.g., "2-4 per chapter")'
    )
    parser.add_argument(
        '--dry-run', '-n',
        action='store_true',
        help='Analyze and select passages without generating commentary'
    )
    parser.add_argument(
        '--annotations-only',
        action='store_true',
        help='Only generate annotations JSON, do not insert into EPUB'
    )
    parser.add_argument(
        '--list-chapters',
        action='store_true',
        help='List available chapters and exit (use to find chapter numbers)'
    )
    parser.add_argument(
        '--chapters',
        help='Process only specific chapters (e.g., "1-3", "4,6,8", "1-3,7")'
    )


def run_annotate(args, verbose: bool = False) -> int:
    """Run the annotate subcommand."""
    import json
    import tempfile

    # Try to import annotator
    try:
        from annotator import (
            load_config as load_annotator_config, create_client, process_epub,
            save_annotations, DEFAULT_CONFIG, list_epub_chapters, parse_chapter_selection
        )
    except ImportError:
        print("Error: Could not import annotator module")
        print("Make sure annotator.py is in the same directory")
        return 1

    # Validate input file
    input_path = Path(args.input)
    if not input_path.exists():
        print(f"Error: Input file not found: {args.input}")
        return 1

    # Handle --list-chapters
    if args.list_chapters:
        print(f"\nChapters in {input_path.name}:\n")
        print(f"{'#':<4} {'Title':<40} {'File':<30}")
        print("-" * 74)
        chapters = list_epub_chapters(str(input_path))
        for ch in chapters:
            title = ch['title'][:38] + '..' if len(ch['title']) > 40 else ch['title']
            print(f"{ch['index']:<4} {title:<40} {ch['file']:<30}")
        print(f"\nTotal: {len(chapters)} files")
        print("\nUse --chapters to select specific chapters, e.g.:")
        print(f"  python cli.py annotate --input {args.input} --chapters 4-6")
        return 0

    # Determine output path
    if args.output:
        output_path = args.output
    else:
        output_path = str(input_path.with_stem(input_path.stem + '_annotated'))

    # Build config
    if args.config:
        config = load_annotator_config(args.config)
    else:
        config = DEFAULT_CONFIG.copy()

    # Override with CLI arguments
    if args.style:
        config['styles'] = [s.strip().lower().replace("'", "").replace(" ", "_")
                           for s in args.style.split(',')]
    if args.frequency:
        config['frequency'] = args.frequency

    # Validate that we have styles
    if not config.get('styles'):
        print("Error: No commentary styles specified.")
        print("Use --style or provide a config file with --config")
        return 1

    # Create LLM client
    client = create_client(config)

    # Parse chapter selection if provided
    chapter_filter = None
    if args.chapters:
        # Get total chapter count first
        chapters = list_epub_chapters(str(input_path))
        chapter_filter = parse_chapter_selection(args.chapters, len(chapters))
        if not chapter_filter:
            print("Error: No valid chapters selected")
            return 1

    # Generate annotations
    annotations = process_epub(
        input_path=str(input_path),
        config=config,
        client=client,
        dry_run=args.dry_run,
        chapter_filter=chapter_filter
    )

    if args.dry_run:
        print(f"\nDry run complete. Would have generated {len(annotations)} annotations.")
        return 0

    if not annotations:
        print("\nNo annotations generated.")
        return 0

    # Save annotations JSON
    annotations_file = output_path.replace('.epub', '_annotations.json')
    save_annotations(annotations, annotations_file, config, str(input_path))

    if args.annotations_only:
        print(f"\nAnnotations saved to: {annotations_file}")
        print("Use footnote_inserter.py to insert them into the EPUB.")
        return 0

    # Insert annotations into EPUB
    try:
        from footnote_inserter import process_epub as insert_footnotes
    except ImportError:
        print("Error: Could not import footnote_inserter module")
        print("Annotations saved to JSON. Use footnote_inserter.py to insert them.")
        return 1

    # Convert annotations to the format expected by footnote_inserter
    # The annotator outputs a different format than footnote_inserter expects
    formatted_annotations = []
    for ann in annotations:
        formatted_annotations.append({
            'chapter': ann['chapter_file'],
            'paragraph_index': ann['paragraph_index'],
            'passage_text': ann['passage_text'],
            'note_text': ann['commentary']['text'],
            'note_type': ann['commentary']['style']
        })

    # Save reformatted annotations to temp file
    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False, encoding='utf-8') as f:
        json.dump(formatted_annotations, f, indent=2, ensure_ascii=False)
        temp_annotations_path = f.name

    try:
        # Insert footnotes
        insert_footnotes(
            input_path=str(input_path),
            annotations_path=temp_annotations_path,
            output_path=output_path,
            note_format=args.format,
            css_filename='footnotes.css'
        )
    finally:
        # Clean up temp file
        os.unlink(temp_annotations_path)

    print(f"\nAnnotated EPUB saved to: {output_path}")
    return 0


# ---------- MAIN CLI ----------

def create_parser() -> argparse.ArgumentParser:
    """Create the main argument parser with all subcommands."""
    parser = argparse.ArgumentParser(
        prog='booksmith',
        description='Booksmith - Unified command-line interface for EPUB editing and analysis',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Commands:
  edit       Core editing - selectively rewrite paragraphs using LLM
  profile    Build author profile - analyze EPUBs to create style profiles
  validate   Check style drift - compare original vs modified text
  analyze    Extract book model - characters, plot, timeline, relationships
  plan       Plan changes - generate modification plans
  check      Verify consistency - cross-chapter validation
  estimate   Estimate API costs - preview costs before processing
  annotate   Add commentary - generate footnotes/endnotes in various styles

Examples:
  python cli.py edit --input book.epub --output clean.epub
  python cli.py profile --input *.epub --output author.json
  python cli.py validate --original original.txt --modified modified.txt
  python cli.py analyze --input book.epub --output model.json
  python cli.py estimate --input book.epub --workflow transform --model opus
  python cli.py annotate --input book.epub --style scholarly,funny --output annotated.epub
  python cli.py --workflow cleanup --input book.epub

Use 'python cli.py <command> --help' for more information on a specific command.
        """
    )

    # Global arguments
    parser.add_argument(
        '--version',
        action='version',
        version=f'%(prog)s {__version__}'
    )
    parser.add_argument(
        '--verbose', '-v',
        action='store_true',
        help='Enable verbose output for all subcommands'
    )
    parser.add_argument(
        '--workflow', '-w',
        help='Load preset configuration from workflows/ directory'
    )

    # Create subparsers
    subparsers = parser.add_subparsers(
        dest='command',
        title='commands',
        metavar='<command>'
    )

    # Set up all subcommand parsers
    setup_edit_parser(subparsers)
    setup_profile_parser(subparsers)
    setup_validate_parser(subparsers)
    setup_analyze_parser(subparsers)
    setup_plan_parser(subparsers)
    setup_check_parser(subparsers)
    setup_estimate_parser(subparsers)
    setup_annotate_parser(subparsers)

    return parser


def apply_workflow_to_args(args, workflow: dict) -> argparse.Namespace:
    """
    Apply workflow configuration to parsed arguments.

    Workflow settings act as defaults - explicit CLI arguments take precedence.
    """
    # Get the subcommand-specific config from workflow
    command_config = workflow.get(args.command, {})

    # Also check for global settings
    global_config = {k: v for k, v in workflow.items()
                     if k not in ['edit', 'profile', 'validate', 'analyze',
                                   'plan', 'check', 'annotate']}

    # Merge configs (command-specific overrides global)
    merged_config = {**global_config, **command_config}

    # Apply to args (only if arg is not explicitly set)
    for key, value in merged_config.items():
        # Convert YAML key to argparse key (e.g., 'dry-run' -> 'dry_run')
        arg_key = key.replace('-', '_')

        # Only set if not already provided via CLI
        if hasattr(args, arg_key):
            current_value = getattr(args, arg_key)
            # Check if it's the default/unset value
            if current_value is None or current_value is False:
                setattr(args, arg_key, value)

    return args


def main() -> int:
    """Main entry point for the CLI."""
    parser = create_parser()
    args = parser.parse_args()

    # Handle no command
    if args.command is None:
        # Check if workflow was specified without a command
        if args.workflow:
            # Try to infer command from workflow
            workflow = load_workflow(args.workflow)
            if 'command' in workflow:
                args.command = workflow['command']
            else:
                print("Error: --workflow specified but no command given.")
                print("Usage: python cli.py <command> --workflow <name>")
                print("   or: python cli.py --workflow <name>  (if workflow specifies 'command')")
                parser.print_help()
                return 1
        else:
            parser.print_help()
            return 0

    # Load and apply workflow if specified
    if args.workflow:
        workflow = load_workflow(args.workflow)
        args = apply_workflow_to_args(args, workflow)

    # Route to appropriate subcommand
    command_runners = {
        'edit': run_edit,
        'profile': run_profile,
        'validate': run_validate,
        'analyze': run_analyze,
        'plan': run_plan,
        'check': run_check,
        'estimate': run_estimate,
        'annotate': run_annotate,
    }

    runner = command_runners.get(args.command)
    if runner:
        try:
            return runner(args, verbose=args.verbose)
        except KeyboardInterrupt:
            print("\n\nOperation cancelled by user.")
            return 130
        except Exception as e:
            if args.verbose:
                import traceback
                traceback.print_exc()
            else:
                print(f"Error: {e}")
            return 1
    else:
        print(f"Unknown command: {args.command}")
        parser.print_help()
        return 1


if __name__ == "__main__":
    sys.exit(main())