Organizing Your Codebase

print(f"🔍 Processing file: {filepath}")
file = codebase.get_file(filepath)
 
# Get the directory path for creating new files
dir_path = file.directory.path if file.directory else ""
 
# Iterate through all functions in the file
for function in file.functions:
    # Create new filename based on function name
    new_filepath = f"{dir_path}/{function.name}.py"
    print(f"📝 Creating new file: {new_filepath}")
 
    # Create the new file
    new_file = codebase.create_file(new_filepath)
 
    # Move the function to the new file, including dependencies
    print(f"➡️ Moving function: {function.name}")
    function.move_to_file(new_file, include_dependencies=True)

# Dictionary to track modules and their functions
module_map = {
    "utils": lambda f: f.name.startswith("util_") or f.name.startswith("helper_"),
    "api": lambda f: f.name.startswith("api_") or f.name.startswith("endpoint_"),
    "data": lambda f: f.name.startswith("data_") or f.name.startswith("db_"),
    "core": lambda f: True  # Default module for other functions
}
 
print("🔍 Starting code organization...")
 
# Create module directories if they don't exist
for module in module_map.keys():
    if not codebase.has_directory(module):
        print(f"📁 Creating module directory: {module}")
        codebase.create_directory(module, exist_ok=True)
 
# Process each file in the codebase
for file in codebase.files:
    print(f"\n📄 Processing file: {file.filepath}")
 
    # Skip if file is already in a module directory
    if any(file.filepath.startswith(module) for module in module_map.keys()):
        continue
 
    # Process each function in the file
    for function in file.functions:
        # Determine which module this function belongs to
        target_module = next(
            (module for module, condition in module_map.items()
             if condition(function)),
            "core"
        )
 
        # Create the new file path
        new_filepath = f"{target_module}/{function.name}.py"
 
        print(f"  ➡️ Moving {function.name} to {target_module} module")
 
        # Create new file and move function
        if not codebase.has_file(new_filepath):
            new_file = codebase.create_file(new_filepath)
            function.move_to_file(new_file, include_dependencies=True)
 
print("\n✅ Code organization complete!")

# Create a graph to detect cycles
import networkx as nx
 
# Build dependency graph
G = nx.DiGraph()
 
# Add edges for imports between files
for file in codebase.files:
    for imp in file.imports:
        if imp.from_file:
            G.add_edge(file.filepath, imp.from_file.filepath)
 
# Find cycles in the graph
cycles = list(nx.simple_cycles(G))
 
if not cycles:
    print("✅ No import cycles found!")
    exit()
 
print(f"🔍 Found {len(cycles)} import cycles")
 
# Process each cycle
for cycle in cycles:
    print(f"\n⭕ Processing cycle: {' -> '.join(cycle)}")
 
    # Get the first two files in the cycle
    file1 = codebase.get_file(cycle[0])
    file2 = codebase.get_file(cycle[1])
 
    # Find functions in file1 that are used by file2
    for function in file1.functions:
        if any(usage.file == file2 for usage in function.usages):
            # Create new file for the shared function
            new_filepath = f"shared/{function.name}.py"
            print(f"  ➡️ Moving {function.name} to {new_filepath}")
 
            if not codebase.has_directory("shared"):
                codebase.create_directory("shared")
 
            new_file = codebase.create_file(new_filepath)
            function.move_to_file(new_file, include_dependencies=True)
 
print("\n✅ Import cycles resolved!")