powershell-shell-detection — скилл для Claude Code: оболочки Windows
Скилл powershell-shell-detection помогает определить, где выполняется скрипт: в PowerShell, Git Bash/MSYS2 или cmd. Он пригодится при переносе команд и путей между оболочками Windows.
MIT 211 установок ★ 66 обновлён 2026-06-18
npx skills add JosiahSiegel/claude-plugin-marketplace --skill powershell-shell-detection -a claude-codeЧто делает powershell-shell-detection
Скилл подсказывает, как различать оболочки по переменным окружения и системным командам. Для PowerShell это PSModulePath, для Git Bash/MSYS2 — MSYSTEM; также рассматриваются OSTYPE и вывод uname -s. Есть примеры функций и проверок для скриптов.
Отдельная часть посвящена несовпадениям в путях, переменных окружения и разделителях PATH. Для преобразования путей в Git Bash показаны варианты с cygpath, а для отключения автоматической конвертации аргументов — MSYS_NO_PATHCONV=1 и MSYS2_ARG_CONV_EXCL. Эта конвертация может менять аргументы, начинающиеся с /, поэтому при вызове Windows-бинарников из Git Bash проверяйте их.
Скилл также описывает запуск .ps1 из bash и bash-скриптов из PowerShell, различия CRLF и LF и загрузку профилей. Установка выполняется через npx skills add; после неё файл скилла находится в ~/.claude/skills/powershell-shell-detection/SKILL.md.
Какие задачи решает
- определить, в какой оболочке выполняется скрипт
- преобразовать путь между форматами Windows и Git Bash
- предотвратить нежелательную конвертацию аргументов в MSYS2
- вызвать
.ps1из bash или bash-скрипт из PowerShell - учесть различия переменных окружения и окончаний строк
Примеры запросов агенту
- Определи, выполняется ли этот скрипт в PowerShell или Git Bash, и предложи проверку.
- Покажи, как передать путь
/c/UsersWindows-бинарнику из Git Bash без нежелательной конвертации. - Объясни, как запустить этот
.ps1из bash и передать ему переменные окружения.
Как установить powershell-shell-detection
1Через Skills CLI (Vercel)
npx skills add JosiahSiegel/claude-plugin-marketplace --skill powershell-shell-detection -a claude-code2Вручную: положить файлы
~/.claude/skills/powershell-shell-detection/SKILL.mdПапка скилла целиком; для одного проекта — .claude/skills/powershell-shell-detection/
1Через Skills CLI (Vercel)
npx skills add JosiahSiegel/claude-plugin-marketplace --skill powershell-shell-detection -a codex2Вручную: положить файлы
.agents/skills/powershell-shell-detection/SKILL.mdДля всех проектов — ~/.agents/skills/
1Через Skills CLI (Vercel)
npx skills add JosiahSiegel/claude-plugin-marketplace --skill powershell-shell-detection -a cursor2Вручную: положить файлы
.cursor/skills/powershell-shell-detection/SKILL.mdCursor читает и .agents/skills/, и .claude/skills/
1GitHub CLI
gh skill install JosiahSiegel/claude-plugin-marketplace plugins/powershell-master/skills/powershell-shell-detection2Вручную: положить файлы
.github/skills/powershell-shell-detection/SKILL.md1Через Skills CLI (Vercel)
npx skills add JosiahSiegel/claude-plugin-marketplace --skill powershell-shell-detection -a gemini-cli2Командой платформы
gemini skills install https://github.com/JosiahSiegel/claude-plugin-marketplace --path plugins/powershell-master/skills/powershell-shell-detectionВручную: положить файлы
.devin/skills/powershell-shell-detection/SKILL.mdСтарый путь .windsurf/skills/ тоже читается
Через Skills CLI (Vercel)
npx skills add JosiahSiegel/claude-plugin-marketplace --skill powershell-shell-detection -a opencodeClaude.ai
Упакуйте папку в zip и загрузите в Settings → Capabilities → Skills
По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов
Вопросы о powershell-shell-detection
Как установить powershell-shell-detection в Claude Code?
Выполните npx skills add JosiahSiegel/claude-plugin-marketplace --skill powershell-shell-detection -a claude-code. Файл скилла появится по пути ~/.claude/skills/powershell-shell-detection/SKILL.md.
Что делает powershell-shell-detection?
Помогает распознавать PowerShell и Git Bash/MSYS2 и учитывать различия оболочек при работе с путями, переменными и запуске скриптов.
Как отключить конвертацию путей в Git Bash?
Для отключения всей конвертации используйте export MSYS_NO_PATHCONV=1. В MSYS2 также можно задать исключения через MSYS2_ARG_CONV_EXCL.
Исходный текст
SKILL.md · MIT
---
name: powershell-shell-detection
description: |
PowerShell vs Git Bash/MSYS2 shell detection and cross-shell compatibility on Windows.
PROACTIVELY activate for: (1) detecting whether script runs under PowerShell, pwsh, Git Bash, or cmd, (2) shell-specific path handling, (3) MSYS_NO_PATHCONV when calling Windows binaries from Git Bash, (4) PowerShell from Git Bash and vice versa, (5) line-ending differences (CRLF vs LF), (6) environment variable differences (env: VAR vs VAR vs percent VAR percent), (7) calling PowerShell scripts (.ps1) from bash and bash scripts from PowerShell, (8) profile loading differences.
Provides: shell-detection one-liners, path-conversion helpers, env-var portability patterns, and cross-shell invocation recipes.
---
# PowerShell Shell Detection & Cross-Shell Compatibility
Critical guidance for distinguishing between PowerShell and Git Bash/MSYS2 shells on Windows, with shell-specific path handling and compatibility notes.
## Shell Detection Priority (Windows)
When working on Windows, correctly identifying the shell environment is crucial for proper path handling and command execution.
### Detection Order (Most Reliable First)
1. **process.env.PSModulePath** (PowerShell specific)
2. **process.env.MSYSTEM** (Git Bash/MinGW specific)
3. **process.env.WSL_DISTRO_NAME** (WSL specific)
4. **uname -s output** (Cross-shell, requires execution)
## PowerShell Detection
### Primary Indicators
**PSModulePath (Most Reliable):**
```powershell
# PowerShell detection
if ($env:PSModulePath) {
Write-Host "Running in PowerShell"
# PSModulePath contains 3+ paths separated by semicolons
$env:PSModulePath -split ';'
}
# Check PowerShell version
$PSVersionTable.PSVersion
# Output: 7.5.4 (PowerShell 7) or 5.1.x (Windows PowerShell)
```
**PowerShell-Specific Variables:**
```powershell
# These only exist in PowerShell
$PSVersionTable # Version info
$PSScriptRoot # Script directory
$PSCommandPath # Script full path
$IsWindows # Platform detection (PS 7+)
$IsLinux # Platform detection (PS 7+)
$IsMacOS # Platform detection (PS 7+)
```
### Shell Type Detection in Scripts
```powershell
function Get-ShellType {
if ($PSVersionTable) {
return "PowerShell $($PSVersionTable.PSVersion)"
}
elseif ($env:PSModulePath -and ($env:PSModulePath -split ';').Count -ge 3) {
return "PowerShell (detected via PSModulePath)"
}
else {
return "Not PowerShell"
}
}
Get-ShellType
```
## Git Bash / MSYS2 Detection
### Primary Indicators
**MSYSTEM Environment Variable (Most Reliable):**
```bash
# Bash detection in Git Bash/MSYS2
if [ -n "$MSYSTEM" ]; then
echo "Running in Git Bash/MSYS2: $MSYSTEM"
fi
# MSYSTEM values:
# MINGW64 - Native Windows 64-bit environment
# MINGW32 - Native Windows 32-bit environment
# MSYS - POSIX-compliant build environment
```
**Secondary Detection Methods:**
```bash
# Using OSTYPE (Bash-specific)
case "$OSTYPE" in
msys*) echo "MSYS/Git Bash" ;;
cygwin*) echo "Cygwin" ;;
linux*) echo "Linux" ;;
darwin*) echo "macOS" ;;
esac
# Using uname (Most portable)
case "$(uname -s)" in
MINGW64*) echo "Git Bash 64-bit" ;;
MINGW32*) echo "Git Bash 32-bit" ;;
MSYS*) echo "MSYS" ;;
CYGWIN*) echo "Cygwin" ;;
Linux*) echo "Linux" ;;
Darwin*) echo "macOS" ;;
esac
```
## Cross-Shell Compatibility on Windows
### Critical Differences
| Aspect | PowerShell | Git Bash/MSYS2 |
|--------|-----------|----------------|
| **Environment Variable** | `$env:VARIABLE` | `$VARIABLE` |
| **Path Separator** | `;` (semicolon) | `:` (colon) |
| **Path Style** | `C:\Windows\System32` | `/c/Windows/System32` |
| **Home Directory** | `$env:USERPROFILE` | `$HOME` |
| **Temp Directory** | `$env:TEMP` | `/tmp` |
| **Command Format** | `Get-ChildItem` | `ls` (native command) |
| **Aliases** | PowerShell cmdlet aliases | Unix command aliases |
### Path Handling: PowerShell vs Git Bash
**PowerShell Path Handling:**
```powershell
# Native Windows paths work directly
$path = "C:\Users\John\Documents"
Test-Path $path # True
# Forward slashes also work in PowerShell 7+
$path = "C:/Users/John/Documents"
Test-Path $path # True
# Use Join-Path for cross-platform compatibility
$configPath = Join-Path -Path $PSScriptRoot -ChildPath "config.json"
# Use [System.IO.Path] for advanced scenarios
$fullPath = [System.IO.Path]::Combine($home, "documents", "file.txt")
```
**Git Bash Path Handling:**
```bash
# Git Bash uses Unix-style paths
path="/c/Users/John/Documents"
test -d "$path" && echo "Directory exists"
# Automatic path conversion (CAUTION)
# Git Bash converts Unix-style paths to Windows-style
# /c/Users → C:\Users (automatic)
# Arguments starting with / may be converted unexpectedly
# Use cygpath for manual conversion
cygpath -u "C:\path" # → /c/path (Unix format)
cygpath -w "/c/path" # → C:\path (Windows format)
cygpath -m "/c/path" # → C:/path (Mixed format)
```
## Automatic Path Conversion in Git Bash (CRITICAL)
Git Bash/MSYS2 automatically converts paths in certain scenarios, which can cause issues:
### What Triggers Conversion
```bash
# Leading forward slash triggers conversion
command /foo # Converts to C:\msys64\foo
# Path lists with colons
export PATH=/foo:/bar # Converts to C:\msys64\foo;C:\msys64\bar
# Arguments after dashes
command --path=/foo # Converts to --path=C:\msys64\foo
```
### What's Exempt from Conversion
```bash
# Arguments with equals sign (variable assignments)
VAR=/foo command # NOT converted
# Drive specifiers
command C:/path # NOT converted
# Arguments with semicolons (already Windows format)
command "C:\foo;D:\bar" # NOT converted
# Double slashes (Windows switches)
command //e //s # NOT converted
```
### Disabling Path Conversion
```bash
# Disable ALL conversion (Git Bash)
export MSYS_NO_PATHCONV=1
command /foo # Stays as /foo
# Exclude specific patterns (MSYS2)
export MSYS2_ARG_CONV_EXCL="*" # Exclude everything
export MSYS2_ARG_CONV_EXCL="--dir=;/test" # Specific prefixes
```
## When to Use PowerShell vs Git Bash on Windows
### Use PowerShell When:
- ✅ **Windows-specific tasks** - Registry, WMI, Windows services
- ✅ **Azure/Microsoft 365 automation** - Az, Microsoft.Graph modules
- ✅ **Module ecosystem** - Leverage PSGallery modules
- ✅ **Object-oriented pipelines** - Rich object manipulation
- ✅ **Native Windows integration** - Built into Windows
- ✅ **CI/CD with pwsh** - GitHub Actions, Azure DevOps
- ✅ **Cross-platform scripting** - PowerShell 7 works on Linux/macOS
**Example PowerShell Scenario:**
```powershell
# Azure VM management with Az module
Connect-AzAccount
Get-AzVM -ResourceGroupName "Production" |
Where-Object {$_.PowerState -eq "VM running"} |
Stop-AzVM -Force
```
### Use Git Bash When:
- ✅ **Unix tool compatibility** - sed, awk, grep, find
- ✅ **Git operations** - Native Git command-line experience
- ✅ **POSIX script execution** - Running Linux shell scripts
- ✅ **Cross-platform shell scripts** - Bash scripts from Linux/macOS
- ✅ **Text processing** - Unix text utilities (sed, awk, cut)
- ✅ **Development workflows** - Node.js, Python, Ruby with Unix tools
**Example Git Bash Scenario:**
```bash
# Git workflow with Unix tools
git log --oneline | grep -i "feature" | awk '{print $1}' |
xargs git show --stat
```
## Shell-Aware Script Design
### Detect and Adapt (PowerShell)
```powershell
# Detect if running in PowerShell or Git Bash context
function Test-PowerShellContext {
return ($null -ne $PSVersionTable)
}
# Adapt path handling based on context
function Get-CrossPlatformPath {
param([string]$Path)
if (Test-PowerShellContext) {
# PowerShell: Use Join-Path
return (Resolve-Path $Path -ErrorAction SilentlyContinue).Path
}
else {
# Non-PowerShell context
Write-Warning "Not running in PowerShell. Path operations may differ."
return $Path
}
}
```
### Detect and Adapt (Bash)
```bash
# Detect shell environment
detect_shell() {
if [ -n "$MSYSTEM" ]; then
echo "git-bash"
elif [ -n "$PSModulePath" ]; then
echo "powershell"
elif [ -n "$WSL_DISTRO_NAME" ]; then
echo "wsl"
else
echo "unix"
fi
}
# Adapt path handling
convert_path() {
local path="$1"
local shell_type=$(detect_shell)
case "$shell_type" in
git-bash)
# Convert Windows path to Unix style
echo "$path" | sed 's|\\|/|g' | sed 's|^\([A-Z]\):|/\L\1|'
;;
*)
echo "$path"
;;
esac
}
# Usage
shell_type=$(detect_shell)
echo "Running in: $shell_type"
```
## Environment Variable Comparison
### Common Environment Variables
| Variable | PowerShell | Git Bash | Purpose |
|----------|-----------|----------|---------|
| **Username** | `$env:USERNAME` | `$USER` | Current user |
| **Home Directory** | `$env:USERPROFILE` | `$HOME` | User home |
| **Temp Directory** | `$env:TEMP` | `/tmp` | Temporary files |
| **Path List** | `$env:Path` (`;` sep) | `$PATH` (`:` sep) | Executable paths |
| **Shell Detection** | `$env:PSModulePath` | `$MSYSTEM` | Shell identifier |
### Cross-Shell Variable Access
**PowerShell accessing environment variables:**
```powershell
$env:PATH # Current PATH
$env:PSModulePath # PowerShell module paths
$env:MSYSTEM # Would be empty in PowerShell
[Environment]::GetEnvironmentVariable("PATH", "Machine") # System PATH
```
**Git Bash accessing environment variables:**
```bash
echo $PATH # Current PATH
echo $MSYSTEM # Git Bash: MINGW64, MINGW32, or MSYS
echo $PSModulePath # Would be empty in pure Bash
```
## Practical Examples
### Example 1: Cross-Shell File Finding
**PowerShell:**
```powershell
# Find files modified in last 7 days
Get-ChildItem -Path "C:\Projects" -Recurse -File |
Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-7) } |
Select-Object FullName, LastWriteTime
```
**Git Bash:**
```bash
# Same operation in Git Bash
find /c/Projects -type f -mtime -7 -exec ls -lh {} \;
```
### Example 2: Process Management
**PowerShell:**
```powershell
# Stop all Chrome processes
Get-Process chrome -ErrorAction SilentlyContinue | Stop-Process -Force
```
**Git Bash:**
```bash
# Same operation in Git Bash
ps aux | grep chrome | awk '{print $2}' | xargs kill -9 2>/dev/null
```
### Example 3: Text File Processing
**PowerShell:**
```powershell
# Extract unique email addresses from logs
Get-Content "logs.txt" |
Select-String -Pattern '\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b' |
ForEach-Object { $_.Matches.Value } |
Sort-Object -Unique
```
**Git Bash:**
```bash
# Same operation in Git Bash
grep -oE '\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b' logs.txt |
sort -u
```
## Troubleshooting Cross-Shell Issues
### Issue 1: Command Not Found
**Problem:** Command works in one shell but not another
```powershell
# PowerShell
Get-Process # Works
```
```bash
# Git Bash
Get-Process # Command not found
```
**Solution:** Understand that PowerShell cmdlets don't exist in Bash. Use native commands or install PowerShell Core (pwsh) in Git Bash:
```bash
# Run PowerShell from Git Bash
pwsh -Command "Get-Process"
```
### Issue 2: Path Format Mismatches
**Problem:** Paths don't work across shells
```bash
# Git Bash path
/c/Users/John/file.txt # Works in Bash
# PowerShell
Test-Path "/c/Users/John/file.txt" # May fail
```
**Solution:** Use cygpath for conversion or normalize paths:
```bash
# Convert to Windows format for PowerShell
win_path=$(cygpath -w "/c/Users/John/file.txt")
pwsh -Command "Test-Path '$win_path'"
```
### Issue 3: Alias Conflicts
**Problem:** `ls`, `cd`, `cat` behave differently
```powershell
# PowerShell
ls # Actually runs Get-ChildItem
```
```bash
# Git Bash
ls # Runs native Unix ls command
```
**Solution:** Use full cmdlet names in PowerShell scripts:
```powershell
# Instead of: ls
Get-ChildItem # Explicit cmdlet name
```
## Best Practices Summary
### PowerShell Scripts
1. ✅ Use `$PSScriptRoot` for script-relative paths
2. ✅ Use `Join-Path` or `[IO.Path]::Combine()` for paths
3. ✅ Avoid hardcoded backslashes
4. ✅ Use full cmdlet names (no aliases)
5. ✅ Test on all target platforms
6. ✅ Use `$IsWindows`, `$IsLinux`, `$IsMacOS` for platform detection
### Git Bash Scripts
1. ✅ Check `$MSYSTEM` for Git Bash detection
2. ✅ Use `cygpath` for path conversion when needed
3. ✅ Set `MSYS_NO_PATHCONV=1` to disable auto-conversion if needed
4. ✅ Quote paths with spaces
5. ✅ Use Unix-style paths (`/c/...`) within Bash
6. ✅ Convert to Windows paths when calling Windows tools
### Cross-Shell Development
1. ✅ Document which shell your script requires
2. ✅ Add shell detection at script start
3. ✅ Provide clear error messages for wrong shell
4. ✅ Consider creating wrapper scripts for cross-shell compatibility
5. ✅ Test in both PowerShell and Git Bash if supporting both
## Resources
- [PowerShell Documentation](https://learn.microsoft.com/powershell)
- [Git for Windows Documentation](https://git-scm.com/doc)
- [MSYS2 Documentation](https://www.msys2.org/docs/what-is-msys2/)
- [Cygpath Documentation](https://www.cygwin.com/cygwin-ug-net/cygpath.html)
---
**Last Updated:** October 2025
© JosiahSiegel · MIT · JosiahSiegel/claude-plugin-marketplace