cli.py

"""
Command-line interface for LLM-Bisect.
"""
import argparse
import logging
import sys
import json
from typing import Optional

from .config import Config, set_config, get_config
from .bisect import bisect_vulnerability, Bisector
from .analysis import evaluate_bisect_accuracy
from .utils.file_utils import save_json, load_json


def setup_logging(verbose: bool = False) -> None:
    """Configure logging based on verbosity level."""
    level = logging.DEBUG if verbose else logging.INFO
    logging.basicConfig(
        level=level,
        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
    )


def cmd_bisect(args: argparse.Namespace) -> int:
    """Execute bisect command."""
    logger = logging.getLogger(__name__)
    
    if args.commit:
        # Single commit mode
        logger.info(f"Bisecting vulnerability fix: {args.commit}")
        result = bisect_vulnerability(args.commit)
        
        if result.success:
            logger.info(f"Bug-inducing commit: {result.inducing_commit}")
            print(f"Inducing commit: {result.inducing_commit}")
        else:
            logger.error(f"Bisect failed: {result.error}")
            return 1
        
        if args.output:
            save_json({args.commit: result.inducing_commit}, args.output)
    
    elif args.input:
        # Batch mode from file
        commits = load_json(args.input, [])
        if isinstance(commits, dict):
            commits = list(commits.keys())
        
        logger.info(f"Processing {len(commits)} commits")
        results = {}
        
        for commit in commits:
            logger.info(f"Processing {commit}")
            result = bisect_vulnerability(commit)
            results[commit] = result.inducing_commit
            
            if result.success:
                logger.info(f"  -> {result.inducing_commit}")
            else:
                logger.warning(f"  -> Failed: {result.error}")
        
        if args.output:
            save_json(results, args.output)
        else:
            print(json.dumps(results, indent=2))
    
    else:
        logger.error("Either --commit or --input must be specified")
        return 1
    
    return 0


def cmd_evaluate(args: argparse.Namespace) -> int:
    """Execute evaluation command."""
    logger = logging.getLogger(__name__)
    
    logger.info(f"Evaluating results from {args.results}")
    
    result = evaluate_bisect_accuracy(args.results, args.ground_truth)
    
    print(f"\nEvaluation Results:")
    print(f"  Total:    {result.total}")
    print(f"  Correct:  {result.correct}")
    print(f"  Incorrect: {result.incorrect}")
    print(f"  Accuracy: {result.accuracy:.2%}")
    
    if result.true_positives > 0 or result.false_positives > 0:
        print(f"\nVersion-based Metrics:")
        print(f"  Precision: {result.precision:.2%}")
        print(f"  Recall:    {result.recall:.2%}")
        print(f"  F1 Score:  {result.f1_score:.2%}")
    
    if args.show_incorrect and result.incorrect_commits:
        print(f"\nIncorrect commits:")
        for commit in result.incorrect_commits:
            print(f"  - {commit}")
    
    return 0


def cmd_analyze(args: argparse.Namespace) -> int:
    """Execute analysis command."""
    logger = logging.getLogger(__name__)
    
    from .analysis import extract_critical_lines
    
    logger.info(f"Analyzing patch: {args.commit}")
    
    lines = extract_critical_lines(args.commit, use_llm=not args.no_llm)
    
    print(f"\nCritical lines in {args.commit}:")
    for line in lines:
        print(f"  {line.filename}:{line.absolute_line} - {line.content[:60]}")
    
    return 0


def create_parser() -> argparse.ArgumentParser:
    """Create the argument parser."""
    parser = argparse.ArgumentParser(
        prog="llm-bisect",
        description="LLM-powered Bug-Inducing Commit Identification",
    )
    
    parser.add_argument(
        "-v", "--verbose",
        action="store_true",
        help="Enable verbose output",
    )
    parser.add_argument(
        "--kernel-path",
        help="Path to Linux kernel repository",
    )
    parser.add_argument(
        "--model",
        default="o1",
        help="LLM model to use (default: o1)",
    )
    
    subparsers = parser.add_subparsers(dest="command", help="Commands")
    
    # Bisect command
    bisect_parser = subparsers.add_parser("bisect", help="Find bug-inducing commit")
    bisect_parser.add_argument(
        "-c", "--commit",
        help="Single patch commit to bisect",
    )
    bisect_parser.add_argument(
        "-i", "--input",
        help="Input JSON file with commits to process",
    )
    bisect_parser.add_argument(
        "-o", "--output",
        help="Output JSON file for results",
    )
    bisect_parser.set_defaults(func=cmd_bisect)
    
    # Evaluate command
    eval_parser = subparsers.add_parser("evaluate", help="Evaluate bisect results")
    eval_parser.add_argument(
        "results",
        help="JSON file with bisect results",
    )
    eval_parser.add_argument(
        "-g", "--ground-truth",
        required=True,
        help="JSON file with ground truth",
    )
    eval_parser.add_argument(
        "--show-incorrect",
        action="store_true",
        help="Show list of incorrect commits",
    )
    eval_parser.set_defaults(func=cmd_evaluate)
    
    # Analyze command
    analyze_parser = subparsers.add_parser("analyze", help="Analyze a patch")
    analyze_parser.add_argument(
        "commit",
        help="Patch commit to analyze",
    )
    analyze_parser.add_argument(
        "--no-llm",
        action="store_true",
        help="Disable LLM-based analysis",
    )
    analyze_parser.set_defaults(func=cmd_analyze)
    
    return parser


def main(argv: Optional[list] = None) -> int:
    """Main entry point."""
    parser = create_parser()
    args = parser.parse_args(argv)
    
    setup_logging(args.verbose)
    
    # Configure
    config = get_config()
    if args.kernel_path:
        config.paths.kernel_repo = args.kernel_path
    if args.model:
        config.llm.model = args.model
    config.debug = args.verbose
    set_config(config)
    
    if not args.command:
        parser.print_help()
        return 1
    
    return args.func(args)


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