cli.py

import ast
import astor
import argparse
import sys

from obfuscate import Obfuscator

def obfuscate_code(filename, output_filename=None):
    import os
    
    with open(filename, 'r') as f:
        source_code = f.read()
    root_node = ast.parse(source_code)
    node = ast.fix_missing_locations(Obfuscator().visit(root_node))
    
    # Extract directory and basename
    dirname = os.path.dirname(filename)
    basename = os.path.basename(filename)
    
    # Create output path in the same directory
    if output_filename is not None:
        output_path = output_filename
    elif dirname:
        output_path = os.path.join(dirname, f'obfuscated_{basename}')
    else:
        output_path = f'obfuscated_{basename}'
    
    with open(output_path, 'w') as f:
        f.write(astor.to_source(node))

    return node, output_path

def main():
    parser = argparse.ArgumentParser(
        description='Obfuscate Python code using lambda calculus transformations'
    )
    parser.add_argument(
        'input_file',
        help='Python file to obfuscate'
    )
    parser.add_argument(
        '-o', '--output',
        help='Output file name (default: obfuscated_<input_file>)',
        default=None
    )
    parser.add_argument(
        '--execute',
        action='store_true',
        help='Execute the obfuscated code after generation'
    )

    args = parser.parse_args()

    try:
        tree, output_file = obfuscate_code(args.input_file, args.output)
        
        print(f"Successfully obfuscated {args.input_file} -> {output_file}")

        if args.execute:
            print("\nExecuting obfuscated code...")
            code = compile(tree, filename="<ast>", mode="exec")
            exec(code)

    except FileNotFoundError:
        print(f"Error: File '{args.input_file}' not found", file=sys.stderr)
        sys.exit(1)
    # except Exception as e:
    #     print(f"Error: {e}", file=sys.stderr)
    #     sys.exit(1)


if __name__ == '__main__':
    main()