|
<# |
|
.SYNOPSIS |
|
Copy Git-untracked or Git-modified files from one Git repository, |
|
or from many Git repositories found at an exact folder depth. |
|
|
|
.DESCRIPTION |
|
- Copies files that are modified: staged or unstaged. |
|
- Copies untracked files. |
|
- Copies Git-ignored dotfiles, such as .env and .env.development. |
|
- Optionally includes ignored files via -IncludeIgnored. |
|
- Optionally skips files larger than -MaxFileSizeBytes. |
|
- Skips common cache/build/package directories: |
|
node_modules, bin, obj, __pycache__, vendor, dist, build, etc. |
|
- Original single-repo mode is preserved when -Depth is not provided. |
|
- Bulk mode is enabled when -Depth is provided. |
|
- In bulk mode, repositories are searched exactly at the given depth below -From. |
|
|
|
.EXAMPLE |
|
.\Copy-GitDirtyFiles.ps1 -From "C:\src\myrepo" -To "D:\backup\myrepo-dirty" |
|
|
|
.EXAMPLE |
|
.\Copy-GitDirtyFiles.ps1 -From "C:\src\myrepo" -To "D:\backup\myrepo-dirty" -IncludeIgnored |
|
|
|
.EXAMPLE |
|
.\Copy-GitDirtyFiles.ps1 -From "Z:\Dev" -To "D:\backup\Dev-dirty" -Depth 2 |
|
|
|
Searches exactly two directory levels below Z:\Dev and copies dirty files |
|
from every Git repository found there. |
|
|
|
.EXAMPLE |
|
.\Copy-GitDirtyFiles.ps1 -From "Z:\Dev" -To "D:\backup\Dev-dirty" -Depth 2 -IncludeIgnored |
|
|
|
.EXAMPLE |
|
.\Copy-GitDirtyFiles.ps1 -From "C:\src\myrepo" -To "D:\backup\myrepo-dirty" -MaxFileSizeBytes 1048576 |
|
#> |
|
|
|
[CmdletBinding()] |
|
param( |
|
[Parameter(Mandatory = $false)] |
|
[string] $From, |
|
|
|
[Parameter(Mandatory = $false)] |
|
[string] $To, |
|
|
|
[Parameter(Mandatory = $false)] |
|
[switch] $IncludeIgnored, |
|
|
|
# Optional. |
|
# If omitted, script behaves like the original single-repository script. |
|
# If provided, script searches for Git repositories exactly this many |
|
# directory levels below -From. |
|
# |
|
# Example: |
|
# -From Z:\Dev -Depth 1 => Z:\Dev\* |
|
# -From Z:\Dev -Depth 2 => Z:\Dev\*\* |
|
# -From Z:\Dev -Depth 3 => Z:\Dev\*\*\* |
|
[Parameter(Mandatory = $false)] |
|
[int] $Depth = -1, |
|
|
|
# Optional. |
|
# If set to 0 or greater, files larger than this many bytes are skipped. |
|
# If omitted or set to -1, no file-size limit is applied. |
|
[Parameter(Mandatory = $false)] |
|
[long] $MaxFileSizeBytes = -1 |
|
) |
|
|
|
Set-StrictMode -Version Latest |
|
$ErrorActionPreference = "Stop" |
|
|
|
if ($MaxFileSizeBytes -lt -1) { |
|
throw "MaxFileSizeBytes cannot be less than -1. Use -1 for unlimited, or a non-negative byte limit." |
|
} |
|
|
|
function Resolve-AbsolutePath { |
|
param([Parameter(Mandatory)] [string] $Path) |
|
|
|
$expanded = [Environment]::ExpandEnvironmentVariables($Path) |
|
$resolved = Resolve-Path -LiteralPath $expanded -ErrorAction Stop |
|
return $resolved.Path |
|
} |
|
|
|
function Ensure-Directory { |
|
param([Parameter(Mandatory)] [string] $Dir) |
|
|
|
if (-not (Test-Path -LiteralPath $Dir -PathType Container)) { |
|
New-Item -ItemType Directory -Path $Dir -Force | Out-Null |
|
} |
|
} |
|
|
|
function Assert-GitAvailable { |
|
$git = Get-Command git -ErrorAction SilentlyContinue |
|
if (-not $git) { |
|
throw "git executable not found in PATH." |
|
} |
|
} |
|
|
|
function Test-GitRepo { |
|
param([Parameter(Mandatory)] [string] $RepoRoot) |
|
|
|
$isRepo = & git -C $RepoRoot rev-parse --is-inside-work-tree 2>$null |
|
return ($LASTEXITCODE -eq 0 -and $isRepo -eq "true") |
|
} |
|
|
|
function Assert-GitRepo { |
|
param([Parameter(Mandatory)] [string] $RepoRoot) |
|
|
|
Assert-GitAvailable |
|
|
|
if (-not (Test-GitRepo -RepoRoot $RepoRoot)) { |
|
throw "No Git repository found at '$RepoRoot' or inside it. Initialize Git first or choose another source folder." |
|
} |
|
} |
|
|
|
function Get-GitTopLevel { |
|
param([Parameter(Mandatory)] [string] $RepoAnyPath) |
|
|
|
$top = & git -C $RepoAnyPath rev-parse --show-toplevel 2>$null |
|
if ($LASTEXITCODE -ne 0 -or [string]::IsNullOrWhiteSpace($top)) { |
|
throw "Failed to resolve Git top-level directory for '$RepoAnyPath'." |
|
} |
|
|
|
return $top.Trim() |
|
} |
|
|
|
# Common folders that should never be copied. |
|
# Match is path-segment based, so it catches nested occurrences. |
|
$IgnoredDirNames = @( |
|
# AWS |
|
".aws-sam", ".serverless", |
|
|
|
# Node / JS |
|
"node_modules", "bower_components", ".yarn", ".pnp", ".pnpm-store", ".npm", ".turbo", ".next", ".nuxt", ".output", |
|
"dist", "build", ".cache", "cache", ".parcel-cache", ".vite", ".svelte-kit", ".angular", "out" |
|
|
|
# Python |
|
"__pycache__", ".pytest_cache", ".mypy_cache", ".ruff_cache", ".tox", ".nox", |
|
".venv", "venv", "env", "site-packages", ".eggs", "egg-info", |
|
|
|
# .NET |
|
"bin", "obj", ".vs", "TestResults", "packages", ".nuget", |
|
|
|
# Java / JVM |
|
"target", ".gradle", "build", ".idea", ".classpath", ".project", ".settings", |
|
|
|
# Go |
|
"vendor", |
|
|
|
# Rust |
|
"target", |
|
|
|
# PHP / Composer |
|
"vendor", |
|
|
|
# Ruby |
|
"vendor", ".bundle", |
|
|
|
# iOS / macOS |
|
"Pods", "DerivedData", |
|
|
|
# Misc VCS / tooling caches |
|
".git", ".svn", ".hg", |
|
|
|
# Visual Studio |
|
".vsdbg", ".vs", "TestResults" |
|
) | Sort-Object -Unique |
|
|
|
function Should-IgnorePath { |
|
param([Parameter(Mandatory)] [string] $RelativePath) |
|
|
|
$p = $RelativePath.Replace('\', '/') |
|
while ($p.StartsWith('./', [System.StringComparison]::Ordinal)) { |
|
$p = $p.Substring(2) |
|
} |
|
$p = $p.TrimStart('/') |
|
$segments = $p.Split('/', [System.StringSplitOptions]::RemoveEmptyEntries) |
|
|
|
foreach ($seg in $segments) { |
|
if ($IgnoredDirNames -contains $seg) { |
|
return $true |
|
} |
|
} |
|
|
|
return $false |
|
} |
|
|
|
function Get-RepoDotFilePaths { |
|
param([Parameter(Mandatory)] [string] $RepoRoot) |
|
|
|
$results = New-Object System.Collections.Generic.List[string] |
|
$stack = New-Object System.Collections.Generic.Stack[System.IO.DirectoryInfo] |
|
$stack.Push((Get-Item -LiteralPath $RepoRoot)) |
|
|
|
while ($stack.Count -gt 0) { |
|
$dir = $stack.Pop() |
|
$children = @(Get-ChildItem -LiteralPath $dir.FullName -Force -ErrorAction SilentlyContinue) |
|
|
|
foreach ($child in $children) { |
|
$relative = (Get-RelativePath -BasePath $RepoRoot -ChildPath $child.FullName).Replace('\', '/') |
|
|
|
if ($child.PSIsContainer) { |
|
if (-not (Should-IgnorePath -RelativePath $relative)) { |
|
$stack.Push($child) |
|
} |
|
|
|
continue |
|
} |
|
|
|
if ($child.Name.StartsWith(".", [System.StringComparison]::Ordinal) -and |
|
-not (Should-IgnorePath -RelativePath $relative)) { |
|
$results.Add($relative) |
|
} |
|
} |
|
} |
|
|
|
return @($results) |
|
} |
|
|
|
function Get-IgnoredDotFilePaths { |
|
param([Parameter(Mandatory)] [string] $RepoRoot) |
|
|
|
$dotFiles = @(Get-RepoDotFilePaths -RepoRoot $RepoRoot) |
|
if ($dotFiles.Count -eq 0) { |
|
return @() |
|
} |
|
|
|
$ignoredDotFiles = New-Object System.Collections.Generic.List[string] |
|
$batchSize = 100 |
|
|
|
for ($i = 0; $i -lt $dotFiles.Count; $i += $batchSize) { |
|
$last = [Math]::Min($i + $batchSize - 1, $dotFiles.Count - 1) |
|
$batch = @($dotFiles[$i..$last]) |
|
|
|
$batchIgnoredDotFiles = @(& git -C $RepoRoot check-ignore -- $batch 2>$null) |
|
if ($LASTEXITCODE -ne 0 -and $LASTEXITCODE -ne 1) { |
|
throw "Failed in '$RepoRoot': git check-ignore" |
|
} |
|
|
|
foreach ($p in $batchIgnoredDotFiles) { |
|
if (-not [string]::IsNullOrWhiteSpace($p)) { |
|
$ignoredDotFiles.Add($p.Trim()) |
|
} |
|
} |
|
} |
|
|
|
return @($ignoredDotFiles) |
|
} |
|
|
|
function Get-DirtyPaths { |
|
param( |
|
[Parameter(Mandatory)] [string] $RepoRoot, |
|
[Parameter(Mandatory)] [bool] $IncludeIgnoredFiles |
|
) |
|
|
|
$set = New-Object System.Collections.Generic.HashSet[string] |
|
|
|
# 1) Modified tracked files: unstaged |
|
$modifiedUnstaged = & git -C $RepoRoot diff --name-only 2>$null |
|
if ($LASTEXITCODE -ne 0) { |
|
throw "Failed in '$RepoRoot': git diff --name-only" |
|
} |
|
|
|
foreach ($p in $modifiedUnstaged) { |
|
if (-not [string]::IsNullOrWhiteSpace($p)) { |
|
[void] $set.Add($p.Trim()) |
|
} |
|
} |
|
|
|
# 2) Modified tracked files: staged |
|
$modifiedStaged = & git -C $RepoRoot diff --cached --name-only 2>$null |
|
if ($LASTEXITCODE -ne 0) { |
|
throw "Failed in '$RepoRoot': git diff --cached --name-only" |
|
} |
|
|
|
foreach ($p in $modifiedStaged) { |
|
if (-not [string]::IsNullOrWhiteSpace($p)) { |
|
[void] $set.Add($p.Trim()) |
|
} |
|
} |
|
|
|
# 3) Untracked, but not ignored |
|
$untracked = & git -C $RepoRoot ls-files -o --exclude-standard 2>$null |
|
if ($LASTEXITCODE -ne 0) { |
|
throw "Failed in '$RepoRoot': git ls-files -o --exclude-standard" |
|
} |
|
|
|
foreach ($p in $untracked) { |
|
if (-not [string]::IsNullOrWhiteSpace($p)) { |
|
[void] $set.Add($p.Trim()) |
|
} |
|
} |
|
|
|
# 4) Ignored dotfiles, such as .env and .env.development. |
|
$ignoredDotFiles = @(Get-IgnoredDotFilePaths -RepoRoot $RepoRoot) |
|
foreach ($p in $ignoredDotFiles) { |
|
if (-not [string]::IsNullOrWhiteSpace($p)) { |
|
[void] $set.Add($p.Trim()) |
|
} |
|
} |
|
|
|
# 5) Ignored files, if requested |
|
if ($IncludeIgnoredFiles) { |
|
$ignored = & git -C $RepoRoot ls-files -o -i --exclude-standard 2>$null |
|
if ($LASTEXITCODE -ne 0) { |
|
throw "Failed in '$RepoRoot': git ls-files -o -i --exclude-standard" |
|
} |
|
|
|
foreach ($p in $ignored) { |
|
if (-not [string]::IsNullOrWhiteSpace($p)) { |
|
[void] $set.Add($p.Trim()) |
|
} |
|
} |
|
} |
|
|
|
return @($set) |
|
} |
|
|
|
function Copy-DirtyFiles { |
|
param( |
|
[Parameter(Mandatory)] [string] $RepoRoot, |
|
[Parameter(Mandatory)] [string] $DestinationRoot, |
|
[Parameter(Mandatory)] [bool] $IncludeIgnoredFiles, |
|
[Parameter(Mandatory)] [long] $MaxFileSizeBytes |
|
) |
|
|
|
$dirty = @(Get-DirtyPaths -RepoRoot $RepoRoot -IncludeIgnoredFiles $IncludeIgnoredFiles) |
|
|
|
if ($dirty.Count -eq 0) { |
|
if ($IncludeIgnoredFiles) { |
|
Write-Host "No modified, untracked, or ignored files found. Nothing to copy." |
|
} else { |
|
Write-Host "No modified, untracked, or ignored dotfiles found. Other ignored files are hidden unless -IncludeIgnored is set." |
|
} |
|
|
|
return @{ |
|
Copied = 0 |
|
Skipped = 0 |
|
SkippedSize = 0 |
|
Missing = 0 |
|
Dirty = 0 |
|
} |
|
} |
|
|
|
$copied = 0 |
|
$skipped = 0 |
|
$skippedSize = 0 |
|
$missing = 0 |
|
|
|
foreach ($rel in $dirty) { |
|
if (Should-IgnorePath -RelativePath $rel) { |
|
$skipped++ |
|
continue |
|
} |
|
|
|
$src = Join-Path -Path $RepoRoot -ChildPath $rel |
|
|
|
$srcItem = Get-Item -LiteralPath $src -ErrorAction SilentlyContinue |
|
if (-not $srcItem -or $srcItem.PSIsContainer) { |
|
$missing++ |
|
continue |
|
} |
|
|
|
if ($MaxFileSizeBytes -ge 0 -and $srcItem.Length -gt $MaxFileSizeBytes) { |
|
$skippedSize++ |
|
continue |
|
} |
|
|
|
$dst = Join-Path -Path $DestinationRoot -ChildPath $rel |
|
$dstDir = Split-Path -Path $dst -Parent |
|
|
|
Ensure-Directory -Dir $dstDir |
|
|
|
Copy-Item -LiteralPath $srcItem.FullName -Destination $dst -Force |
|
$copied++ |
|
} |
|
|
|
Write-Host "Copied: $copied" |
|
Write-Host "Skipped by ignored dirs list: $skipped" |
|
Write-Host "Skipped by file size limit: $skippedSize" |
|
Write-Host "Missing or non-file: $missing" |
|
Write-Host "Done." |
|
|
|
return @{ |
|
Copied = $copied |
|
Skipped = $skipped |
|
SkippedSize = $skippedSize |
|
Missing = $missing |
|
Dirty = $dirty.Count |
|
} |
|
} |
|
|
|
function Get-RelativePath { |
|
param( |
|
[Parameter(Mandatory)] [string] $BasePath, |
|
[Parameter(Mandatory)] [string] $ChildPath |
|
) |
|
|
|
$baseFull = [System.IO.Path]::GetFullPath($BasePath) |
|
$childFull = [System.IO.Path]::GetFullPath($ChildPath) |
|
|
|
if (-not $baseFull.EndsWith([System.IO.Path]::DirectorySeparatorChar)) { |
|
$baseFull += [System.IO.Path]::DirectorySeparatorChar |
|
} |
|
|
|
$baseUri = [System.Uri]::new($baseFull) |
|
$childUri = [System.Uri]::new($childFull) |
|
|
|
$relativeUri = $baseUri.MakeRelativeUri($childUri) |
|
$relativePath = [System.Uri]::UnescapeDataString($relativeUri.ToString()) |
|
|
|
return ($relativePath -replace '/', [System.IO.Path]::DirectorySeparatorChar) |
|
} |
|
|
|
function Get-DirectoriesAtExactDepth { |
|
param( |
|
[Parameter(Mandatory)] [string] $Root, |
|
[Parameter(Mandatory)] [int] $ExactDepth |
|
) |
|
|
|
if ($ExactDepth -lt 0) { |
|
throw "Depth cannot be negative." |
|
} |
|
|
|
if ($ExactDepth -eq 0) { |
|
return @((Get-Item -LiteralPath $Root)) |
|
} |
|
|
|
$currentLevel = @((Get-Item -LiteralPath $Root)) |
|
|
|
for ($level = 1; $level -le $ExactDepth; $level++) { |
|
$nextLevel = @() |
|
|
|
foreach ($dir in $currentLevel) { |
|
# Do not descend into already detected Git working trees. |
|
# This keeps the search focused on project folders and avoids scanning |
|
# huge dependency/cache trees inside repositories. |
|
if ($level -gt 1 -and (Test-Path -LiteralPath (Join-Path $dir.FullName ".git"))) { |
|
continue |
|
} |
|
|
|
$children = Get-ChildItem -LiteralPath $dir.FullName -Directory -Force -ErrorAction SilentlyContinue | |
|
Where-Object { |
|
$IgnoredDirNames -notcontains $_.Name |
|
} |
|
|
|
foreach ($child in $children) { |
|
$nextLevel += $child |
|
} |
|
} |
|
|
|
$currentLevel = $nextLevel |
|
} |
|
|
|
return @($currentLevel) |
|
} |
|
|
|
function Find-GitReposAtExactDepth { |
|
param( |
|
[Parameter(Mandatory)] [string] $Root, |
|
[Parameter(Mandatory)] [int] $ExactDepth |
|
) |
|
|
|
Assert-GitAvailable |
|
|
|
$candidateDirs = @(Get-DirectoriesAtExactDepth -Root $Root -ExactDepth $ExactDepth) |
|
$repos = New-Object System.Collections.Generic.HashSet[string] |
|
|
|
foreach ($dir in $candidateDirs) { |
|
if (-not (Test-GitRepo -RepoRoot $dir.FullName)) { |
|
continue |
|
} |
|
|
|
$top = Get-GitTopLevel -RepoAnyPath $dir.FullName |
|
|
|
# Important: |
|
# Only accept repositories whose top-level is exactly the candidate path. |
|
# This prevents a child folder inside a repository from being counted as |
|
# the repository when searching a deeper level. |
|
$candidateFull = [System.IO.Path]::GetFullPath($dir.FullName).TrimEnd('\', '/') |
|
$topFull = [System.IO.Path]::GetFullPath($top).TrimEnd('\', '/') |
|
|
|
if ([string]::Equals($candidateFull, $topFull, [System.StringComparison]::OrdinalIgnoreCase)) { |
|
[void] $repos.Add($topFull) |
|
} |
|
} |
|
|
|
return @($repos) |
|
} |
|
|
|
# --- Main flow --- |
|
|
|
if ([string]::IsNullOrWhiteSpace($From)) { |
|
$From = Read-Host "Source folder" |
|
} |
|
|
|
if ([string]::IsNullOrWhiteSpace($To)) { |
|
$To = Read-Host "Destination folder" |
|
} |
|
|
|
$FromAbs = Resolve-AbsolutePath -Path $From |
|
|
|
$ToExpanded = [Environment]::ExpandEnvironmentVariables($To) |
|
if (-not (Test-Path -LiteralPath $ToExpanded)) { |
|
Ensure-Directory -Dir $ToExpanded |
|
} |
|
|
|
$ToAbs = Resolve-AbsolutePath -Path $ToExpanded |
|
|
|
# Single-repository mode: original behavior. |
|
if ($Depth -lt 0) { |
|
Assert-GitRepo -RepoRoot $FromAbs |
|
$repoTop = Get-GitTopLevel -RepoAnyPath $FromAbs |
|
|
|
Write-Host "Mode: Single repository" |
|
Write-Host "Git repo top-level: $repoTop" |
|
Write-Host "Copy destination: $ToAbs" |
|
Write-Host "Ignored dotfiles: Included" |
|
Write-Host ("Other ignored files: " + $(if ($IncludeIgnored.IsPresent) { "Included" } else { "Hidden" })) |
|
Write-Host ("File size limit: " + $(if ($MaxFileSizeBytes -ge 0) { "$MaxFileSizeBytes bytes" } else { "Unlimited" })) |
|
|
|
Copy-DirtyFiles ` |
|
-RepoRoot $repoTop ` |
|
-DestinationRoot $ToAbs ` |
|
-IncludeIgnoredFiles $IncludeIgnored.IsPresent ` |
|
-MaxFileSizeBytes $MaxFileSizeBytes | Out-Null |
|
|
|
exit 0 |
|
} |
|
|
|
# Bulk mode. |
|
Write-Host "Mode: Bulk repositories" |
|
Write-Host "Search root: $FromAbs" |
|
Write-Host "Search depth: $Depth" |
|
Write-Host "Copy destination: $ToAbs" |
|
Write-Host "Ignored dotfiles: Included" |
|
Write-Host ("Other ignored files: " + $(if ($IncludeIgnored.IsPresent) { "Included" } else { "Hidden" })) |
|
Write-Host ("File size limit: " + $(if ($MaxFileSizeBytes -ge 0) { "$MaxFileSizeBytes bytes" } else { "Unlimited" })) |
|
Write-Host "" |
|
|
|
$repos = @(Find-GitReposAtExactDepth -Root $FromAbs -ExactDepth $Depth | Sort-Object) |
|
|
|
if ($repos.Count -eq 0) { |
|
Write-Host "No Git repositories found exactly at depth $Depth below '$FromAbs'." |
|
exit 0 |
|
} |
|
|
|
Write-Host "Git repositories found: $($repos.Count)" |
|
Write-Host "" |
|
|
|
$totalCopied = 0 |
|
$totalSkipped = 0 |
|
$totalSkippedSize = 0 |
|
$totalMissing = 0 |
|
$totalDirty = 0 |
|
$processed = 0 |
|
$failed = 0 |
|
|
|
foreach ($repo in $repos) { |
|
$processed++ |
|
|
|
$relativeRepoPath = Get-RelativePath -BasePath $FromAbs -ChildPath $repo |
|
$repoDestination = Join-Path -Path $ToAbs -ChildPath $relativeRepoPath |
|
|
|
Write-Host "[$processed/$($repos.Count)] Repository: $repo" |
|
Write-Host "Destination: $repoDestination" |
|
|
|
try { |
|
Ensure-Directory -Dir $repoDestination |
|
|
|
$result = Copy-DirtyFiles ` |
|
-RepoRoot $repo ` |
|
-DestinationRoot $repoDestination ` |
|
-IncludeIgnoredFiles $IncludeIgnored.IsPresent ` |
|
-MaxFileSizeBytes $MaxFileSizeBytes |
|
|
|
$totalCopied += [int] $result.Copied |
|
$totalSkipped += [int] $result.Skipped |
|
$totalSkippedSize += [int] $result.SkippedSize |
|
$totalMissing += [int] $result.Missing |
|
$totalDirty += [int] $result.Dirty |
|
} |
|
catch { |
|
$failed++ |
|
Write-Warning "Failed to process repository '$repo': $($_.Exception.Message)" |
|
} |
|
|
|
Write-Host "" |
|
} |
|
|
|
Write-Host "Bulk copy summary" |
|
Write-Host "-----------------" |
|
Write-Host "Repositories found: $($repos.Count)" |
|
Write-Host "Repositories processed: $processed" |
|
Write-Host "Repositories failed: $failed" |
|
Write-Host "Dirty paths detected: $totalDirty" |
|
Write-Host "Files copied: $totalCopied" |
|
Write-Host "Skipped by ignore list: $totalSkipped" |
|
Write-Host "Skipped by size limit: $totalSkippedSize" |
|
Write-Host "Missing or non-file: $totalMissing" |
|
Write-Host "Done." |
