1# Organize-Downloads.ps1
2# Automatically organize files in Downloads folder by type
3
4# Configuration
5$DownloadsPath = "$env:USERPROFILE\Downloads"
6$LogPath = "$env:USERPROFILE\Documents\FileOrganizer.log"
7
8# Define file type categories
9$FileTypes = @{
10    'Images' = @('*.jpg', '*.jpeg', '*.png', '*.gif', '*.bmp', '*.svg', '*.webp', '*.ico')
11    'Documents' = @('*.pdf', '*.doc', '*.docx', '*.txt', '*.rtf', '*.odt', '*.xls', '*.xlsx', '*.ppt', '*.pptx')
12    'Videos' = @('*.mp4', '*.avi', '*.mkv', '*.mov', '*.wmv', '*.flv', '*.webm')
13    'Audio' = @('*.mp3', '*.wav', '*.flac', '*.aac', '*.ogg', '*.wma', '*.m4a')
14    'Archives' = @('*.zip', '*.rar', '*.7z', '*.tar', '*.gz', '*.bz2')
15    'Installers' = @('*.exe', '*.msi', '*.dmg', '*.pkg')
16    'Code' = @('*.py', '*.js', '*.html', '*.css', '*.java', '*.cpp', '*.c', '*.cs', '*.php', '*.rb', '*.go')
17    'Data' = @('*.csv', '*.json', '*.xml', '*.sql', '*.db', '*.sqlite')
18}
19
20# Function to write to log
21function Write-Log {
22    param(
23        [string]$Message,
24        [string]$Level = "INFO"
25    )
26    
27    $Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
28    $LogMessage = "[$Timestamp] [$Level] $Message"
29    
30    # Write to console
31    Write-Host $LogMessage
32    
33    # Write to log file
34    Add-Content -Path $LogPath -Value $LogMessage
35}
36
37# Function to organize files
38function Organize-Files {
39    param(
40        [string]$SourcePath = $DownloadsPath
41    )
42    
43    Write-Log "Starting file organization in: $SourcePath"
44    
45    $FilesProcessed = 0
46    $FilesMoved = 0
47    
48    # Get all files (not directories)
49    $Files = Get-ChildItem -Path $SourcePath -File
50    
51    foreach ($File in $Files) {
52        $FilesProcessed++
53        $Moved = $false
54        
55        # Skip log files
56        if ($File.Name -eq "FileOrganizer.log") {
57            continue
58        }
59        
60        # Check each category
61        foreach ($Category in $FileTypes.Keys) {
62            foreach ($Pattern in $FileTypes[$Category]) {
63                if ($File.Name -like $Pattern) {
64                    # Create category folder if it doesn't exist
65                    $DestinationFolder = Join-Path -Path $SourcePath -ChildPath $Category
66                    
67                    if (-not (Test-Path -Path $DestinationFolder)) {
68                        New-Item -ItemType Directory -Path $DestinationFolder | Out-Null
69                        Write-Log "Created folder: $Category"
70                    }
71                    
72                    # Move file
73                    $DestinationPath = Join-Path -Path $DestinationFolder -ChildPath $File.Name
74                    
75                    try {
76                        Move-Item -Path $File.FullName -Destination $DestinationPath -Force
77                        Write-Log "Moved: $($File.Name) -> $Category"
78                        $FilesMoved++
79                        $Moved = $true
80                        break
81                    }
82                    catch {
83                        Write-Log "ERROR: Failed to move $($File.Name): $_" -Level "ERROR"
84                    }
85                }
86            }
87            
88            if ($Moved) { break }
89        }
90        
91        # If file didn't match any category, move to "Other"
92        if (-not $Moved) {
93            $OtherFolder = Join-Path -Path $SourcePath -ChildPath "Other"
94            
95            if (-not (Test-Path -Path $OtherFolder)) {
96                New-Item -ItemType Directory -Path $OtherFolder | Out-Null
97            }
98            
99            $DestinationPath = Join-Path -Path $OtherFolder -ChildPath $File.Name
100            
101            try {
102                Move-Item -Path $File.FullName -Destination $DestinationPath -Force
103                Write-Log "Moved: $($File.Name) -> Other"
104                $FilesMoved++
105            }
106            catch {
107                Write-Log "ERROR: Failed to move $($File.Name): $_" -Level "ERROR"
108            }
109        }
110    }
111    
112    Write-Log "Organization complete: $FilesMoved of $FilesProcessed files moved"
113}
114
115# Run the organizer
116Organize-Files

1# Function to organize files by date
2function Organize-FilesByDate {
3    param(
4        [string]$SourcePath = $DownloadsPath,
5        [string]$DateFormat = "yyyy-MM"  # Year-Month format
6    )
7    
8    Write-Log "Starting date-based organization in: $SourcePath"
9    
10    $FilesProcessed = 0
11    $FilesMoved = 0
12    
13    $Files = Get-ChildItem -Path $SourcePath -File
14    
15    foreach ($File in $Files) {
16        $FilesProcessed++
17        
18        # Get file creation or modification date
19        $FileDate = $File.LastWriteTime
20        $DateFolder = $FileDate.ToString($DateFormat)
21        
22        # Create dated folder if it doesn't exist
23        $DestinationFolder = Join-Path -Path $SourcePath -ChildPath $DateFolder
24        
25        if (-not (Test-Path -Path $DestinationFolder)) {
26            New-Item -ItemType Directory -Path $DestinationFolder | Out-Null
27            Write-Log "Created folder: $DateFolder"
28        }
29        
30        # Move file
31        $DestinationPath = Join-Path -Path $DestinationFolder -ChildPath $File.Name
32        
33        try {
34            Move-Item -Path $File.FullName -Destination $DestinationPath -Force
35            Write-Log "Moved: $($File.Name) -> $DateFolder"
36            $FilesMoved++
37        }
38        catch {
39            Write-Log "ERROR: Failed to move $($File.Name): $_" -Level "ERROR"
40        }
41    }
42    
43    Write-Log "Date organization complete: $FilesMoved of $FilesProcessed files moved"
44}
45
46# Uncomment to use date-based organization instead:
47# Organize-FilesByDate

1# Function to handle duplicate files
2function Get-UniqueFileName {
3    param(
4        [string]$DestinationPath
5    )
6    
7    if (-not (Test-Path -Path $DestinationPath)) {
8        return $DestinationPath
9    }
10    
11    # File exists, create unique name
12    $Directory = [System.IO.Path]::GetDirectoryName($DestinationPath)
13    $FileName = [System.IO.Path]::GetFileNameWithoutExtension($DestinationPath)
14    $Extension = [System.IO.Path]::GetExtension($DestinationPath)
15    
16    $Counter = 1
17    
18    do {
19        $NewFileName = "$FileName ($Counter)$Extension"
20        $NewPath = Join-Path -Path $Directory -ChildPath $NewFileName
21        $Counter++
22    } while (Test-Path -Path $NewPath)
23    
24    return $NewPath
25}
26
27# Updated move function with duplicate handling
28function Move-FileWithDuplicateCheck {
29    param(
30        [string]$SourcePath,
31        [string]$DestinationPath,
32        [string]$Action = "Rename"  # Options: Rename, Skip, Overwrite
33    )
34    
35    if (Test-Path -Path $DestinationPath) {
36        switch ($Action) {
37            "Rename" {
38                $DestinationPath = Get-UniqueFileName -DestinationPath $DestinationPath
39                Write-Log "Duplicate found, renaming to: $(Split-Path -Leaf $DestinationPath)"
40            }
41            "Skip" {
42                Write-Log "Duplicate found, skipping: $(Split-Path -Leaf $SourcePath)" -Level "WARN"
43                return $false
44            }
45            "Overwrite" {
46                Write-Log "Duplicate found, overwriting: $(Split-Path -Leaf $DestinationPath)" -Level "WARN"
47            }
48        }
49    }
50    
51    try {
52        Move-Item -Path $SourcePath -Destination $DestinationPath -Force
53        return $true
54    }
55    catch {
56        Write-Log "ERROR: Failed to move file: $_" -Level "ERROR"
57        return $false
58    }
59}

1# Define custom organization rules
2$CustomRules = @(
3    @{
4        Name = "Work Invoices"
5        Pattern = "*invoice*.pdf"
6        Destination = "Documents\Invoices"
7    },
8    @{
9        Name = "Screenshots"
10        Pattern = "*screenshot*.png", "*capture*.png"
11        Destination = "Pictures\Screenshots"
12    },
13    @{
14        Name = "Project Files"
15        Pattern = "*project*.zip", "*backup*.zip"
16        Destination = "Projects\Archives"
17    },
18    @{
19        Name = "Client Documents"
20        Pattern = "*contract*.pdf", "*agreement*.pdf"
21        Destination = "Documents\Clients"
22    }
23)
24
25# Function to organize by custom rules
26function Organize-FilesByRules {
27    param(
28        [string]$SourcePath = $DownloadsPath,
29        [array]$Rules = $CustomRules
30    )
31    
32    Write-Log "Starting rule-based organization"
33    
34    $FilesProcessed = 0
35    $FilesMoved = 0
36    
37    $Files = Get-ChildItem -Path $SourcePath -File
38    
39    foreach ($File in $Files) {
40        $FilesProcessed++
41        $Matched = $false
42        
43        foreach ($Rule in $Rules) {
44            foreach ($Pattern in $Rule.Pattern) {
45                if ($File.Name -like $Pattern) {
46                    # Create destination folder
47                    $DestinationFolder = Join-Path -Path $env:USERPROFILE -ChildPath $Rule.Destination
48                    
49                    if (-not (Test-Path -Path $DestinationFolder)) {
50                        New-Item -ItemType Directory -Path $DestinationFolder -Force | Out-Null
51                        Write-Log "Created folder: $($Rule.Destination)"
52                    }
53                    
54                    # Move file
55                    $DestinationPath = Join-Path -Path $DestinationFolder -ChildPath $File.Name
56                    
57                    if (Move-FileWithDuplicateCheck -SourcePath $File.FullName -DestinationPath $DestinationPath -Action "Rename") {
58                        Write-Log "Moved: $($File.Name) -> $($Rule.Name)"
59                        $FilesMoved++
60                        $Matched = $true
61                        break
62                    }
63                }
64            }
65            
66            if ($Matched) { break }
67        }
68        
69        # If no rule matched, fall back to type-based organization
70        if (-not $Matched) {
71            # Call standard organization for this file
72        }
73    }
74    
75    Write-Log "Rule-based organization complete: $FilesMoved of $FilesProcessed files moved"
76}

1# Real-time file watcher
2function Start-FileWatcher {
3    param(
4        [string]$Path = $DownloadsPath
5    )
6    
7    Write-Log "Starting file watcher on: $Path"
8    
9    # Create file system watcher
10    $Watcher = New-Object System.IO.FileSystemWatcher
11    $Watcher.Path = $Path
12    $Watcher.IncludeSubdirectories = $false
13    $Watcher.EnableRaisingEvents = $true
14    
15    # Define what to do when a file is created
16    $Action = {
17        $File = $Event.SourceEventArgs.FullPath
18        $FileName = $Event.SourceEventArgs.Name
19        
20        # Wait a moment for file to be fully written
21        Start-Sleep -Seconds 2
22        
23        Write-Host "New file detected: $FileName"
24        
25        # Organize this specific file
26        # Call your organization function here
27    }
28    
29    # Register event handler
30    Register-ObjectEvent -InputObject $Watcher -EventName Created -Action $Action
31    
32    Write-Host "File watcher is running. Press Ctrl+C to stop."
33    Write-Host "Monitoring: $Path"
34    
35    # Keep script running
36    try {
37        while ($true) {
38            Start-Sleep -Seconds 1
39        }
40    }
41    finally {
42        $Watcher.Dispose()
43    }
44}
45
46# Uncomment to run file watcher:
47# Start-FileWatcher

1# Setup-ScheduledTask.ps1
2# Creates a scheduled task to run file organizer daily
3
4$TaskName = "Organize Downloads Folder"
5$ScriptPath = "C:\Path\To\Your\Organize-Downloads.ps1"
6$TriggerTime = "08:00AM"  # Run at 8 AM daily
7
8# Create action
9$Action = New-ScheduledTaskAction -Execute "PowerShell.exe" `
10    -Argument "-NoProfile -ExecutionPolicy Bypass -File `"$ScriptPath`""
11
12# Create trigger (daily at specified time)
13$Trigger = New-ScheduledTaskTrigger -Daily -At $TriggerTime
14
15# Create settings
16$Settings = New-ScheduledTaskSettingsSet `
17    -AllowStartIfOnBatteries `
18    -DontStopIfGoingOnBatteries `
19    -StartWhenAvailable
20
21# Register task
22Register-ScheduledTask -TaskName $TaskName `
23    -Action $Action `
24    -Trigger $Trigger `
25    -Settings $Settings `
26    -Description "Automatically organize files in Downloads folder" `
27    -RunLevel Highest
28
29Write-Host "Scheduled task created successfully!"
30Write-Host "The script will run daily at $TriggerTime"

1# Copy script to startup
2$StartupFolder = "$env:APPDATA\Microsoft\Windows\Start Menu\Programs\Startup"
3$ShortcutPath = Join-Path -Path $StartupFolder -ChildPath "Organize-Downloads.lnk"
4
5$WScriptShell = New-Object -ComObject WScript.Shell
6$Shortcut = $WScriptShell.CreateShortcut($ShortcutPath)
7$Shortcut.TargetPath = "PowerShell.exe"
8$Shortcut.Arguments = "-NoProfile -ExecutionPolicy Bypass -File `"C:\Path\To\Organize-Downloads.ps1`""
9$Shortcut.WorkingDirectory = "$env:USERPROFILE\Downloads"
10$Shortcut.WindowStyle = 7  # Minimized
11$Shortcut.Save()
12
13Write-Host "Startup shortcut created!"

1# Function to organize by file size
2function Organize-FilesBySize {
3    param(
4        [string]$SourcePath = $DownloadsPath
5    )
6    
7    Write-Log "Starting size-based organization"
8    
9    $Files = Get-ChildItem -Path $SourcePath -File
10    
11    foreach ($File in $Files) {
12        $SizeMB = [math]::Round($File.Length / 1MB, 2)
13        
14        # Determine size category
15        $SizeCategory = switch ($SizeMB) {
16            {$_ -lt 1} { "Small (< 1MB)" }
17            {$_ -ge 1 -and $_ -lt 10} { "Medium (1-10MB)" }
18            {$_ -ge 10 -and $_ -lt 100} { "Large (10-100MB)" }
19            {$_ -ge 100} { "Very Large (100MB+)" }
20        }
21        
22        # Create folder and move file
23        $DestinationFolder = Join-Path -Path $SourcePath -ChildPath $SizeCategory
24        
25        if (-not (Test-Path -Path $DestinationFolder)) {
26            New-Item -ItemType Directory -Path $DestinationFolder | Out-Null
27        }
28        
29        $DestinationPath = Join-Path -Path $DestinationFolder -ChildPath $File.Name
30        
31        Move-FileWithDuplicateCheck -SourcePath $File.FullName -DestinationPath $DestinationPath
32    }
33    
34    Write-Log "Size-based organization complete"
35}
36
37# Function to organize by age
38function Organize-FilesByAge {
39    param(
40        [string]$SourcePath = $DownloadsPath,
41        [int]$RecentDays = 7,
42        [int]$OldDays = 30
43    )
44    
45    Write-Log "Starting age-based organization"
46    
47    $Now = Get-Date
48    $Files = Get-ChildItem -Path $SourcePath -File
49    
50    foreach ($File in $Files) {
51        $FileAge = ($Now - $File.LastWriteTime).TotalDays
52        
53        # Determine age category
54        $AgeCategory = switch ($FileAge) {
55            {$_ -le $RecentDays} { "Recent (Last Week)" }
56            {$_ -gt $RecentDays -and $_ -le $OldDays} { "This Month" }
57            {$_ -gt $OldDays -and $_ -le 90} { "Last 3 Months" }
58            {$_ -gt 90} { "Older" }
59        }
60        
61        # Create folder and move file
62        $DestinationFolder = Join-Path -Path $SourcePath -ChildPath $AgeCategory
63        
64        if (-not (Test-Path -Path $DestinationFolder)) {
65            New-Item -ItemType Directory -Path $DestinationFolder | Out-Null
66        }
67        
68        $DestinationPath = Join-Path -Path $DestinationFolder -ChildPath $File.Name
69        
70        Move-FileWithDuplicateCheck -SourcePath $File.FullName -DestinationPath $DestinationPath
71    }
72    
73    Write-Log "Age-based organization complete"
74}

1# Function to archive old files
2function Archive-OldFiles {
3    param(
4        [string]$SourcePath = $DownloadsPath,
5        [int]$DaysOld = 90,
6        [string]$ArchivePath = "$env:USERPROFILE\Documents\Archives"
7    )
8    
9    Write-Log "Starting old file archival (files older than $DaysOld days)"
10    
11    $CutoffDate = (Get-Date).AddDays(-$DaysOld)
12    $Files = Get-ChildItem -Path $SourcePath -File -Recurse | Where-Object { $_.LastWriteTime -lt $CutoffDate }
13    
14    if ($Files.Count -eq 0) {
15        Write-Log "No files to archive"
16        return
17    }
18    
19    # Create archive folder
20    if (-not (Test-Path -Path $ArchivePath)) {
21        New-Item -ItemType Directory -Path $ArchivePath | Out-Null
22    }
23    
24    $ArchiveZip = Join-Path -Path $ArchivePath -ChildPath "Downloads_Archive_$(Get-Date -Format 'yyyyMMdd').zip"
25    
26    # Compress old files
27    Compress-Archive -Path $Files.FullName -DestinationPath $ArchiveZip -CompressionLevel Optimal
28    
29    Write-Log "Archived $($Files.Count) files to: $ArchiveZip"
30    
31    # Optional: Delete original files after archiving
32    # $Files | Remove-Item -Force
33}
34
35# Function to delete very old files
36function Remove-VeryOldFiles {
37    param(
38        [string]$SourcePath = $DownloadsPath,
39        [int]$DaysOld = 180
40    )
41    
42    Write-Log "Starting deletion of files older than $DaysOld days"
43    
44    $CutoffDate = (Get-Date).AddDays(-$DaysOld)
45    $Files = Get-ChildItem -Path $SourcePath -File -Recurse | Where-Object { $_.LastWriteTime -lt $CutoffDate }
46    
47    if ($Files.Count -eq 0) {
48        Write-Log "No files to delete"
49        return
50    }
51    
52    Write-Host "WARNING: About to delete $($Files.Count) files older than $DaysOld days"
53    Write-Host "Files will be deleted:"
54    $Files | Select-Object Name, LastWriteTime | Format-Table
55    
56    $Confirmation = Read-Host "Type 'YES' to confirm deletion"
57    
58    if ($Confirmation -eq 'YES') {
59        $Files | Remove-Item -Force
60        Write-Log "Deleted $($Files.Count) old files"
61    }
62    else {
63        Write-Log "Deletion cancelled by user"
64    }
65}

1# File-Organizer-Master.ps1
2# Comprehensive file organization tool
3
4param(
5    [switch]$Auto,
6    [switch]$Watch,
7    [string]$Mode = "Type"  # Options: Type, Date, Size, Age, Rules
8)
9
10# [Include all functions from above]
11
12# Main menu
13function Show-Menu {
14    Clear-Host
15    Write-Host "================================"
16    Write-Host "   FILE ORGANIZER v1.0"
17    Write-Host "================================"
18    Write-Host ""
19    Write-Host "1. Organize by Type (Images, Documents, etc.)"
20    Write-Host "2. Organize by Date (Year-Month folders)"
21    Write-Host "3. Organize by Size (Small, Medium, Large)"
22    Write-Host "4. Organize by Age (Recent, This Month, Older)"
23    Write-Host "5. Organize by Custom Rules"
24    Write-Host "6. Start Real-Time File Watcher"
25    Write-Host "7. Archive Files Older Than 90 Days"
26    Write-Host "8. Delete Files Older Than 180 Days"
27    Write-Host "9. Configure Settings"
28    Write-Host "0. Exit"
29    Write-Host ""
30    $Choice = Read-Host "Select an option"
31    
32    return $Choice
33}
34
35# Main execution
36if ($Auto) {
37    # Run automatically (called by scheduled task)
38    Organize-Files
39}
40elseif ($Watch) {
41    # Start file watcher
42    Start-FileWatcher
43}
44else {
45    # Interactive menu
46    do {
47        $Choice = Show-Menu
48        
49        switch ($Choice) {
50            '1' { Organize-Files }
51            '2' { Organize-FilesByDate }
52            '3' { Organize-FilesBySize }
53            '4' { Organize-FilesByAge }
54            '5' { Organize-FilesByRules }
55            '6' { Start-FileWatcher }
56            '7' { Archive-OldFiles }
57            '8' { Remove-VeryOldFiles }
58            '9' { Write-Host "Settings menu coming soon..."; Start-Sleep -Seconds 2 }
59            '0' { break }
60            default { Write-Host "Invalid option"; Start-Sleep -Seconds 1 }
61        }
62        
63        if ($Choice -ne '0') {
64            Write-Host "`nPress any key to return to menu..."
65            $null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown")
66        }
67    } while ($Choice -ne '0')
68}

1# Test mode: copy instead of move
2Copy-Item instead of Move-Item

1# Review recent actions
2Get-Content "$env:USERPROFILE\Documents\FileOrganizer.log" -Tail 50

1# Backup entire Downloads folder
2Copy-Item -Path $DownloadsPath -Destination "$DownloadsPath-Backup" -Recurse

1$ExcludeFolders = @('Work-In-Progress', 'Current-Projects')
2
3# Skip if file is in excluded folder
4if ($ExcludeFolders -contains $File.Directory.Name) {
5    continue
6}

1# Set execution policy (run as Administrator)
2Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

1# Test if you have write permissions
2Test-Path -Path $DownloadsPath -PathType Container

1# Debug: Add verbose output
2Write-Host "Checking for duplicate: $DestinationPath"