Hve Core Installer

# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
<#
.SYNOPSIS
    Copies selected HVE-Core agents to the target repository.
.DESCRIPTION
    Creates .github/agents/ directory, copies agent files, computes SHA256 hashes,
    and writes .hve-tracking.json manifest for upgrade tracking.
.PARAMETER HveCoreBasePath
    Root path of the local HVE-Core clone used as the copy source.
.PARAMETER CollectionId
    Collection identifier recorded in the tracking manifest.
.PARAMETER FilesToCopy
    Array of agent file paths relative to the source agents directory.
.PARAMETER KeepExisting
    When set, existing files listed in Collisions are preserved instead of overwritten.
.PARAMETER Collisions
    Array of target file paths that already exist and may conflict.
.EXAMPLE
    ./scripts/agent-copy.ps1 -HveCoreBasePath ../hve-core -CollectionId hve-core -FilesToCopy @('hve-core/task-researcher.agent.md')
.OUTPUTS
    Per-file copy status and manifest creation confirmation.
#>
[CmdletBinding()]
param(
    [Parameter(Mandatory)]
    [ValidateScript({ Test-Path $_ })]
    [string]$HveCoreBasePath,

    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string]$CollectionId,

    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string[]]$FilesToCopy,

    [Parameter()]
    [switch]$KeepExisting,

    [Parameter()]
    [string[]]$Collisions = @()
)

$ErrorActionPreference = 'Stop'

$sourceBase = "$hveCoreBasePath/.github/agents"
$targetDir = ".github/agents"
$manifestPath = ".hve-tracking.json"

# Create target directory
if (-not (Test-Path $targetDir)) {
    New-Item -ItemType Directory -Path $targetDir -Force | Out-Null
    Write-Host "✅ Created $targetDir"
}

# Initialize manifest
$manifest = @{
    source = "microsoft/hve-core"
    version = (Get-Content "$hveCoreBasePath/package.json" | ConvertFrom-Json).version
    installed = (Get-Date -Format "o")
    collection = $collectionId  # "hve-core" or collection id(s) e.g. "developer" or "developer,devops"
    files = @{}; skip = @()
}

# Copy files (source paths are relative to agents/, target is flat)
foreach ($file in $filesToCopy) {
    $fileName = Split-Path $file -Leaf
    $sourcePath = Join-Path $sourceBase $file
    $targetPath = Join-Path $targetDir $fileName
    $relPath = ".github/agents/$fileName"

    if ($keepExisting -and $collisions -contains $targetPath) {
        Write-Host "⏭️ Kept existing: $fileName"; continue
    }

    Set-Content -Path $targetPath -Value (Get-Content $sourcePath -Raw) -NoNewline
    $hash = (Get-FileHash -Path $targetPath -Algorithm SHA256).Hash.ToLower()
    $manifest.files[$relPath] = @{ version = $manifest.version; sha256 = $hash; status = "managed" }
    Write-Host "✅ Copied $fileName"
}

$manifest | ConvertTo-Json -Depth 10 | Set-Content $manifestPath
Write-Host "✅ Created $manifestPath"

#!/usr/bin/env bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
# Copies selected HVE-Core agents to the target repository.
# Creates .github/agents/, copies agent files, computes SHA256 hashes,
# and writes .hve-tracking.json manifest for upgrade tracking.
# Usage: agent-copy.sh <hve_core_base_path> <collection_id> <file1> [file2...]
#   Files are paths relative to the agents/ directory.
set -euo pipefail

hve_core_base_path="${1:?Usage: $0 <hve_core_base_path> <collection_id> <file1> [file2...]}"
collection_id="${2:?Usage: $0 <hve_core_base_path> <collection_id> <file1> [file2...]}"
shift 2

source_base="$hve_core_base_path/.github/agents"
target_dir=".github/agents"
manifest_path=".hve-tracking.json"
keep_existing="${KEEP_EXISTING:-false}"
collisions_file="${COLLISIONS_FILE:-}"
has_jq=false
command -v jq >/dev/null 2>&1 && has_jq=true

# Load collision list when keep_existing is enabled
declare -A collision_set
if [ "$keep_existing" = "true" ] && [ -n "$collisions_file" ] && [ -f "$collisions_file" ]; then
    while IFS= read -r line; do
        [ -n "$line" ] && collision_set["$line"]=1
    done < "$collisions_file"
fi

# Create target directory
mkdir -p "$target_dir"

# Get version from package.json
if [ "$has_jq" = true ]; then
    version=$(jq -r '.version' "$hve_core_base_path/package.json")
else
    version=$(grep -o '"version": *"[^"]*"' "$hve_core_base_path/package.json" | head -1 | sed 's/.*"\([^"]*\)"/\1/')
fi

# Initialize manifest JSON
installed=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
files_json="{}"

# Copy files (source paths are relative to agents/, target is flat)
for file in "$@"; do
    filename=$(basename "$file")
    source_path="$source_base/$file"
    target_path="$target_dir/$filename"
    rel_path=".github/agents/$filename"

    # Skip files the user chose to keep during collision resolution
    if [ "$keep_existing" = "true" ] && [ -n "${collision_set[$target_path]+x}" ]; then
        echo "⏭️ Kept existing: $filename"
        continue
    fi

    cp "$source_path" "$target_path"
    hash=$(sha256sum "$target_path" | cut -d' ' -f1)
    if [ "$has_jq" = true ]; then
        files_json=$(echo "$files_json" | jq --arg path "$rel_path" --arg ver "$version" --arg sha "$hash" \
            '. + {($path): {"version": $ver, "sha256": $sha, "status": "managed"}}')
    else
        # Build JSON entries without jq
        if [ "$files_json" = "{}" ]; then
            files_json="{\"$rel_path\": {\"version\": \"$version\", \"sha256\": \"$hash\", \"status\": \"managed\"}}"
        else
            files_json="${files_json%\}}, \"$rel_path\": {\"version\": \"$version\", \"sha256\": \"$hash\", \"status\": \"managed\"}}"
        fi
    fi
    echo "✅ Copied $filename"
done

# Write manifest
if [ "$has_jq" = true ]; then
    jq -n --arg src "microsoft/hve-core" --arg ver "$version" --arg inst "$installed" \
        --arg col "$collection_id" --argjson files "$files_json" \
        '{source: $src, version: $ver, installed: $inst, collection: $col, files: $files}' \
        > "$manifest_path"
else
    cat > "$manifest_path" <<EOF
{"source": "microsoft/hve-core", "version": "$version", "installed": "$installed", "collection": "$collection_id", "files": $files_json}
EOF
fi
echo "✅ Created $manifest_path"

# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
<#
.SYNOPSIS
    Detects file collisions before copying HVE-Core agents.
.DESCRIPTION
    Checks the target directory for existing agent files that would conflict
    with the selected agent bundle or collection.
.PARAMETER Selection
    Agent bundle to check. Use 'hve-core' for the default set or a collection identifier.
.PARAMETER CollectionAgents
    Array of agent file paths relative to the agents directory for non-default collections.
.EXAMPLE
    ./scripts/collision-detection.ps1 -Selection hve-core
.EXAMPLE
    ./scripts/collision-detection.ps1 -Selection my-collection -CollectionAgents @('my-collection/custom.agent.md')
.OUTPUTS
    COLLISIONS_DETECTED=true/false and COLLISION_FILES list.
#>
[CmdletBinding()]
param(
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string]$Selection,

    [Parameter()]
    [string[]]$CollectionAgents = @()
)

$ErrorActionPreference = 'Stop'

$targetDir = ".github/agents"

# Get files to copy based on selection (paths relative to agents/)
$filesToCopy = switch ($selection) {
    "hve-core" { @("hve-core/task-researcher.agent.md", "hve-core/task-planner.agent.md", "hve-core/task-implementor.agent.md", "hve-core/task-reviewer.agent.md", "hve-core/rpi-agent.agent.md") }
    default {
        # Collection-based: paths from collection manifest relative to agents/
        $collectionAgents
    }
}

# Check for collisions (target uses filename only)
$collisions = @()
foreach ($file in $filesToCopy) {
    $fileName = Split-Path $file -Leaf
    $targetPath = Join-Path $targetDir $fileName
    if (Test-Path $targetPath) { $collisions += $targetPath }
}

if ($collisions.Count -gt 0) {
    Write-Host "COLLISIONS_DETECTED=true"
    Write-Host "COLLISION_FILES=$($collisions -join ',')"
} else {
    Write-Host "COLLISIONS_DETECTED=false"
}

#!/usr/bin/env bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
# Detects file collisions before copying HVE-Core agents.
# Usage: collision-detection.sh <hve_core_base_path> <selection> [collection_agents...]
#   selection: 'hve-core' for RPI core bundle, or collection id
#   collection_agents: space-separated relative paths (when selection is a collection)
set -euo pipefail

hve_core_base_path="${1:?Usage: $0 <hve_core_base_path> <selection> [collection_agents...]}"
selection="${2:?Usage: $0 <hve_core_base_path> <selection> [collection_agents...]}"
shift 2

target_dir=".github/agents"

# Build file list based on selection
case "$selection" in
    hve-core)
        files_to_copy=(
            "hve-core/task-researcher.agent.md"
            "hve-core/task-planner.agent.md"
            "hve-core/task-implementor.agent.md"
            "hve-core/task-reviewer.agent.md"
            "hve-core/rpi-agent.agent.md"
        )
        ;;
    *)
        files_to_copy=("$@")
        ;;
esac

# Check for collisions (target uses filename only)
collisions=()
for file in "${files_to_copy[@]}"; do
    filename=$(basename "$file")
    target_path="$target_dir/$filename"
    if [ -f "$target_path" ]; then
        collisions+=("$target_path")
    fi
done

if [ ${#collisions[@]} -gt 0 ]; then
    echo "COLLISIONS_DETECTED=true"
    IFS=','; echo "COLLISION_FILES=${collisions[*]}"
else
    echo "COLLISIONS_DETECTED=false"
fi

# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
<#
.SYNOPSIS
    Detects the current development environment for HVE-Core installation.
.DESCRIPTION
    Identifies whether the user is in a local VS Code, devcontainer, or Codespaces
    environment and reports relevant configuration details.
.EXAMPLE
    ./scripts/detect-environment.ps1
.OUTPUTS
    Key-value pairs: ENV_TYPE, IS_CODESPACES, IS_DEVCONTAINER,
    HAS_DEVCONTAINER_JSON, HAS_WORKSPACE_FILE, IS_HVE_CORE_REPO.
#>
[CmdletBinding()]
param()

$ErrorActionPreference = 'Stop'

# Detect environment type
$env_type = "local"
$is_codespaces = $false
$is_devcontainer = $false

if ($env:CODESPACES -eq "true") {
    $env_type = "codespaces"
    $is_codespaces = $true
    $is_devcontainer = $true
} elseif ((Test-Path "/.dockerenv") -or ($env:REMOTE_CONTAINERS -eq "true")) {
    $env_type = "devcontainer"
    $is_devcontainer = $true
}

$has_devcontainer_json = Test-Path ".devcontainer/devcontainer.json"
$has_workspace_file = (Get-ChildItem -Filter "*.code-workspace" -ErrorAction SilentlyContinue | Measure-Object).Count -gt 0
try {
    $is_hve_core_repo = (Split-Path (git rev-parse --show-toplevel 2>$null) -Leaf) -eq "hve-core"
} catch {
    $is_hve_core_repo = $false
}

Write-Host "ENV_TYPE=$env_type"
Write-Host "IS_CODESPACES=$is_codespaces"
Write-Host "IS_DEVCONTAINER=$is_devcontainer"
Write-Host "HAS_DEVCONTAINER_JSON=$has_devcontainer_json"
Write-Host "HAS_WORKSPACE_FILE=$has_workspace_file"
Write-Host "IS_HVE_CORE_REPO=$is_hve_core_repo"

#!/usr/bin/env bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
# Detects the current development environment for HVE-Core installation.
# Outputs key-value pairs: ENV_TYPE, IS_CODESPACES, IS_DEVCONTAINER,
# HAS_DEVCONTAINER_JSON, HAS_WORKSPACE_FILE, IS_HVE_CORE_REPO.
set -euo pipefail

# Detect environment type
env_type="local"
is_codespaces=false
is_devcontainer=false

if [ "${CODESPACES:-}" = "true" ]; then
    env_type="codespaces"
    is_codespaces=true
    is_devcontainer=true
elif [ -f "/.dockerenv" ] || [ "${REMOTE_CONTAINERS:-}" = "true" ]; then
    env_type="devcontainer"
    is_devcontainer=true
fi

has_devcontainer_json=false
[ -f ".devcontainer/devcontainer.json" ] && has_devcontainer_json=true

has_workspace_file=false
[ -n "$(find . -maxdepth 1 -name '*.code-workspace' -print -quit 2>/dev/null)" ] && has_workspace_file=true

is_hve_core_repo=false
repo_root=$(git rev-parse --show-toplevel 2>/dev/null || true)
[ -n "$repo_root" ] && [ "$(basename "$repo_root")" = "hve-core" ] && is_hve_core_repo=true

echo "ENV_TYPE=$env_type"
echo "IS_CODESPACES=$is_codespaces"
echo "IS_DEVCONTAINER=$is_devcontainer"
echo "HAS_DEVCONTAINER_JSON=$has_devcontainer_json"
echo "HAS_WORKSPACE_FILE=$has_workspace_file"
echo "IS_HVE_CORE_REPO=$is_hve_core_repo"

# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
<#
.SYNOPSIS
    Ejects a tracked file from HVE-Core upgrade management.
.DESCRIPTION
    Marks a file as 'ejected' in .hve-tracking.json so future upgrades
    skip it. The file remains on disk but is owned by the user.
.PARAMETER FilePath
    The relative path to the file to eject (e.g., .github/agents/task-implementor.agent.md).
.EXAMPLE
    ./scripts/eject.ps1 -FilePath '.github/agents/task-implementor.agent.md'
#>
[CmdletBinding()]
param(
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string]$FilePath
)

$ErrorActionPreference = 'Stop'

$manifest = Get-Content ".hve-tracking.json" | ConvertFrom-Json -AsHashtable

if ($manifest.files.ContainsKey($FilePath)) {
    $manifest.files[$FilePath].status = "ejected"
    $manifest.files[$FilePath].ejectedAt = (Get-Date -Format "o")

    $manifest | ConvertTo-Json -Depth 10 | Set-Content ".hve-tracking.json"
    Write-Host "✅ Ejected: $FilePath"
    Write-Host "   This file will never be updated by HVE-Core."
} else {
    Write-Host "❌ File not found in tracking manifest: $FilePath"
}

#!/usr/bin/env bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
# Ejects a tracked file from HVE-Core upgrade management.
# Marks the file as 'ejected' in .hve-tracking.json so future upgrades skip it.
# Usage: eject.sh <file_path>
set -euo pipefail

file_path="${1:?Usage: $0 <file_path>}"
manifest_path=".hve-tracking.json"

if [ ! -f "$manifest_path" ]; then
    echo "❌ No .hve-tracking.json found" >&2
    exit 1
fi

if jq -e --arg fp "$file_path" '.files[$fp]' "$manifest_path" >/dev/null 2>&1; then
    ejected_at=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
    jq --arg fp "$file_path" --arg ea "$ejected_at" \
        '.files[$fp].status = "ejected" | .files[$fp].ejectedAt = $ea' \
        "$manifest_path" > "${manifest_path}.tmp" && mv "${manifest_path}.tmp" "$manifest_path"
    echo "✅ Ejected: $file_path"
    echo "   This file will never be updated by HVE-Core."
else
    echo "❌ File not found in tracking manifest: $file_path"
fi

# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
<#
.SYNOPSIS
    Compares current agent files against the .hve-tracking.json manifest.
.DESCRIPTION
    For each tracked file, computes the current SHA256 hash and compares it
    against the stored hash to determine status: managed, modified, ejected,
    or missing.
.EXAMPLE
    ./scripts/file-status-check.ps1
.OUTPUTS
    Per-file status lines: FILE=<path>|STATUS=<status>|ACTION=<action>.
#>
[CmdletBinding()]
param()

$ErrorActionPreference = 'Stop'

$manifest = Get-Content ".hve-tracking.json" | ConvertFrom-Json -AsHashtable
$statusReport = @()

foreach ($file in $manifest.files.Keys) {
    $entry = $manifest.files[$file]
    $status = $entry.status

    if ($status -eq "ejected") {
        $statusReport += @{
            file = $file
            status = "ejected"
            action = "Skip (user owns this file)"
        }
        continue
    }

    if (-not (Test-Path $file)) {
        $statusReport += @{
            file = $file
            status = "missing"
            action = "Will restore"
        }
        continue
    }

    $currentHash = (Get-FileHash -Path $file -Algorithm SHA256).Hash.ToLower()
    if ($currentHash -ne $entry.sha256) {
        $statusReport += @{
            file = $file
            status = "modified"
            action = "Requires decision"
            currentHash = $currentHash
            storedHash = $entry.sha256
        }
    } else {
        $statusReport += @{
            file = $file
            status = "managed"
            action = "Will update"
        }
    }
}

$statusReport | ForEach-Object {
    Write-Host "FILE=$($_.file)|STATUS=$($_.status)|ACTION=$($_.action)"
}

#!/usr/bin/env bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
# Compares current agent files against the .hve-tracking.json manifest.
# Requires jq. Outputs per-file status lines.
set -euo pipefail

manifest_path=".hve-tracking.json"
if [ ! -f "$manifest_path" ]; then
    echo "❌ No .hve-tracking.json found" >&2
    exit 1
fi

jq -r '.files | to_entries[] | "\(.key)|\(.value.status)|\(.value.sha256)"' "$manifest_path" | while IFS='|' read -r file status stored_hash; do
    if [ "$status" = "ejected" ]; then
        echo "FILE=$file|STATUS=ejected|ACTION=Skip (user owns this file)"
        continue
    fi

    if [ ! -f "$file" ]; then
        echo "FILE=$file|STATUS=missing|ACTION=Will restore"
        continue
    fi

    current_hash=$(sha256sum "$file" | cut -d' ' -f1)
    if [ "$current_hash" != "$stored_hash" ]; then
        echo "FILE=$file|STATUS=modified|ACTION=Requires decision"
    else
        echo "FILE=$file|STATUS=managed|ACTION=Will update"
    fi
done

# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
<#
.SYNOPSIS
    Detects whether the current installation is eligible for upgrade.
.DESCRIPTION
    Checks for .hve-tracking.json and compares installed version against
    the source HVE-Core version from package.json.
.PARAMETER HveCoreBasePath
    Root path of the local HVE-Core clone containing package.json.
.EXAMPLE
    ./scripts/upgrade-detection.ps1 -HveCoreBasePath ../hve-core
.OUTPUTS
    UPGRADE_MODE, INSTALLED_VERSION, SOURCE_VERSION, VERSION_CHANGED,
    INSTALLED_COLLECTION key-value pairs.
#>
[CmdletBinding()]
param(
    [Parameter(Mandatory)]
    [ValidateScript({ Test-Path $_ })]
    [string]$HveCoreBasePath
)

$ErrorActionPreference = 'Stop'
$manifestPath = ".hve-tracking.json"

if (Test-Path $manifestPath) {
    $manifest = Get-Content $manifestPath | ConvertFrom-Json -AsHashtable
    $sourceVersion = (Get-Content "$hveCoreBasePath/package.json" | ConvertFrom-Json).version

    Write-Host "UPGRADE_MODE=true"
    Write-Host "INSTALLED_VERSION=$($manifest.version)"
    Write-Host "SOURCE_VERSION=$sourceVersion"
    Write-Host "VERSION_CHANGED=$($sourceVersion -ne $manifest.version)"
    $collection = if ($manifest.collection) { $manifest.collection } else { 'hve-core' }
    Write-Host "INSTALLED_COLLECTION=$collection"
} else {
    Write-Host "UPGRADE_MODE=false"
}

#!/usr/bin/env bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
# Detects whether the current installation is eligible for upgrade.
# Checks for .hve-tracking.json and compares installed version against source.
# Usage: upgrade-detection.sh <hve_core_base_path>
set -euo pipefail

hve_core_base_path="${1:?Usage: $0 <hve_core_base_path>}"
manifest_path=".hve-tracking.json"

if [ -f "$manifest_path" ]; then
    if command -v jq >/dev/null 2>&1; then
        installed_version=$(jq -r '.version' "$manifest_path")
        installed_collection=$(jq -r '.collection // "hve-core"' "$manifest_path")
        source_version=$(jq -r '.version' "$hve_core_base_path/package.json")
    else
        installed_version=$(grep -o '"version": *"[^"]*"' "$manifest_path" | head -1 | sed 's/.*"\([^"]*\)"/\1/')
        installed_collection="hve-core"
        source_version=$(grep -o '"version": *"[^"]*"' "$hve_core_base_path/package.json" | head -1 | sed 's/.*"\([^"]*\)"/\1/')
    fi

    version_changed=false
    [ "$source_version" != "$installed_version" ] && version_changed=true

    echo "UPGRADE_MODE=true"
    echo "INSTALLED_VERSION=$installed_version"
    echo "SOURCE_VERSION=$source_version"
    echo "VERSION_CHANGED=$version_changed"
    echo "INSTALLED_COLLECTION=$installed_collection"
else
    echo "UPGRADE_MODE=false"
fi

# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
<#
.SYNOPSIS
    Validates that the HVE Core VS Code extension is installed.
.DESCRIPTION
    Checks the installed extensions list for ise-hve-essentials.hve-core
    and reports version information.
.PARAMETER CodeCli
    Path or name of the VS Code CLI executable. Defaults to 'code'.
.EXAMPLE
    ./scripts/validate-extension.ps1
.EXAMPLE
    ./scripts/validate-extension.ps1 -CodeCli 'code-insiders'
.OUTPUTS
    EXTENSION_INSTALLED=True/False and version details.
#>
[CmdletBinding()]
param(
    [Parameter()]
    [ValidateNotNullOrEmpty()]
    [string]$CodeCli = 'code'
)

$ErrorActionPreference = 'Stop'

# Check if extension is installed
$extensions = & $codeCli --list-extensions 2>$null
if ($extensions -match "ise-hve-essentials.hve-core") {
    Write-Host "✅ HVE Core extension installed successfully"
    $installed = $true
} else {
    Write-Host "❌ Extension not found in installed extensions"
    $installed = $false
}

# Verify version (optional)
$versionOutput = & $codeCli --list-extensions --show-versions 2>$null | Select-String "ise-hve-essentials.hve-core"
if ($versionOutput) {
    Write-Host "📌 Version: $($versionOutput -replace '.*@', '')"
}

Write-Host "EXTENSION_INSTALLED=$installed"

#!/usr/bin/env bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
# Validates that the HVE Core VS Code extension is installed.
# Set code_cli to 'code' or 'code-insiders' before running.
# Outputs EXTENSION_INSTALLED=true/false and version details.
set -euo pipefail

# Set based on user's earlier choice: 'code' or 'code-insiders'
code_cli="${code_cli:-code}"

# Check if extension is installed
if "$code_cli" --list-extensions 2>/dev/null | grep -q "ise-hve-essentials.hve-core"; then
    echo "✅ HVE Core extension installed successfully"
    installed=true
else
    echo "❌ Extension not found in installed extensions"
    installed=false
fi

# Verify version (optional)
version=$("$code_cli" --list-extensions --show-versions 2>/dev/null | grep "ise-hve-essentials.hve-core" | sed 's/.*@//' || true)
[ -n "$version" ] && echo "📌 Version: $version"

echo "EXTENSION_INSTALLED=$installed"

# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
<#
.SYNOPSIS
    Validates an HVE-Core clone-based installation.
.DESCRIPTION
    Checks that required directories exist and method-specific configuration
    is correct (workspace file for multi-root, .gitmodules for submodule).
.PARAMETER BasePath
    Root path of the installation to validate.
.PARAMETER Method
    Installation method number (1-6) that determines which validations to run.
.EXAMPLE
    ./scripts/validate-installation.ps1 -BasePath ./my-project -Method 1
.EXAMPLE
    ./scripts/validate-installation.ps1 -BasePath ./my-project -Method 5
.OUTPUTS
    Per-directory pass/fail status and overall validation result.
#>
[CmdletBinding()]
param(
    [Parameter(Mandatory)]
    [ValidateScript({ Test-Path $_ })]
    [string]$BasePath,

    [Parameter(Mandatory)]
    [ValidateRange(1, 6)]
    [int]$Method
)

$ErrorActionPreference = 'Stop'

$valid = $true
foreach ($dir in @("$basePath/.github/agents", "$basePath/.github/prompts", "$basePath/.github/instructions", "$basePath/.github/skills")) {
    if (-not (Test-Path $dir)) { $valid = $false; Write-Host "❌ Missing: $dir" }
    else { Write-Host "✅ Found: $dir" }
}

# Optional: informational check for experimental subdirectories (absence is not a failure)
foreach ($dir in @("$basePath/.github/skills/experimental", "$basePath/.github/agents/experimental")) {
    if (Test-Path $dir) { Write-Host "ℹ️  Found optional: $dir" }
}

# Method 5 additional check: workspace file
if ($method -eq 5 -and (Test-Path "hve-core.code-workspace")) {
    $workspace = Get-Content "hve-core.code-workspace" | ConvertFrom-Json
    if ($workspace.folders.Count -lt 2) { $valid = $false; Write-Host "❌ Multi-root not configured" }
    else { Write-Host "✅ Multi-root configured" }
}

# Method 6 additional check: submodule
if ($method -eq 6) {
    if (-not (Test-Path ".gitmodules") -or -not (Select-String -Path ".gitmodules" -Pattern "lib/hve-core" -Quiet)) {
        $valid = $false; Write-Host "❌ Submodule not in .gitmodules"
    }
}

if ($valid) { Write-Host "✅ Installation validated successfully" }

#!/usr/bin/env bash
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT
# Validates an HVE-Core clone-based installation.
# Usage: validate-installation.sh <method> <base_path>
#   method:    Installation method number (1-6)
#   base_path: Path to hve-core root directory
set -euo pipefail

if [ "$#" -ne 2 ]; then
    echo "Usage: $0 <method> <base_path>" >&2
    echo "  method:    Installation method number (1-6)" >&2
    echo "  base_path: Path to hve-core root directory" >&2
    exit 1
fi
method="$1"
base_path="$2"

valid=true
for path in "$base_path/.github/agents" "$base_path/.github/prompts" "$base_path/.github/instructions" "$base_path/.github/skills"; do
    if [ -d "$path" ]; then echo "✅ Found: $path"; else echo "❌ Missing: $path"; valid=false; fi
done

# Optional: informational check for experimental subdirectories (absence is not a failure)
for path in "$base_path/.github/skills/experimental" "$base_path/.github/agents/experimental"; do
    if [ -d "$path" ]; then echo "ℹ️  Found optional: $path"; fi
done

# Method 5: workspace file check (requires jq)
if [ "$method" = "5" ]; then
    if ! command -v jq >/dev/null 2>&1; then
        echo "⚠️  jq not installed - skipping workspace JSON validation"
        echo "   Install jq for full validation, or manually verify hve-core.code-workspace has 2+ folders"
    elif [ -f "hve-core.code-workspace" ] && jq -e '.folders | length >= 2' hve-core.code-workspace >/dev/null 2>&1; then
        echo "✅ Multi-root configured"
    else
        echo "❌ Multi-root not configured"; valid=false
    fi
fi

# Method 6: submodule check
[ "$method" = "6" ] && { grep -q "lib/hve-core" .gitmodules 2>/dev/null && echo "✅ Submodule configured" || { echo "❌ Submodule not in .gitmodules"; valid=false; }; }

[ "$valid" = true ] && echo "✅ Installation validated successfully"

#Requires -Modules Pester
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT

Describe 'agent-copy' -Tag 'Unit' {
    BeforeAll {
        $script:scriptPath = Join-Path $PSScriptRoot '../scripts/agent-copy.ps1'
        $script:testRoot = Join-Path ([System.IO.Path]::GetTempPath()) "hve-test-agent-copy-$([guid]::NewGuid().ToString('N'))"
        $script:sourceRoot = Join-Path $script:testRoot 'source'
        $script:targetRoot = Join-Path $script:testRoot 'target'
    }

    BeforeEach {
        # Create clean source and target directories for each test
        New-Item -ItemType Directory -Path $script:sourceRoot -Force | Out-Null
        New-Item -ItemType Directory -Path $script:targetRoot -Force | Out-Null

        # Create source agents directory with sample files
        $agentsDir = Join-Path $script:sourceRoot '.github/agents/hve-core'
        New-Item -ItemType Directory -Path $agentsDir -Force | Out-Null

        Set-Content -Path (Join-Path $agentsDir 'task-researcher.agent.md') -Value '# Researcher' -NoNewline
        Set-Content -Path (Join-Path $agentsDir 'task-planner.agent.md') -Value '# Planner' -NoNewline

        # Create package.json in source
        @{ version = '2.0.0' } | ConvertTo-Json | Set-Content (Join-Path $script:sourceRoot 'package.json')

        Push-Location $script:targetRoot
    }

    AfterEach {
        Pop-Location
    }

    AfterAll {
        if (Test-Path $script:testRoot) {
            Remove-Item $script:testRoot -Recurse -Force -ErrorAction SilentlyContinue
        }
    }

    Context 'Directory creation' {
        It 'Creates .github/agents directory when it does not exist' {
            & $script:scriptPath -HveCoreBasePath $script:sourceRoot -CollectionId 'hve-core' -FilesToCopy @('hve-core/task-researcher.agent.md')

            Test-Path '.github/agents' | Should -BeTrue
        }

        It 'Does not fail when .github/agents directory already exists' {
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null

            { & $script:scriptPath -HveCoreBasePath $script:sourceRoot -CollectionId 'hve-core' -FilesToCopy @('hve-core/task-researcher.agent.md') } | Should -Not -Throw
        }
    }

    Context 'File copying' {
        It 'Copies specified agent files to target directory' {
            & $script:scriptPath -HveCoreBasePath $script:sourceRoot -CollectionId 'hve-core' -FilesToCopy @('hve-core/task-researcher.agent.md', 'hve-core/task-planner.agent.md')

            Test-Path '.github/agents/task-researcher.agent.md' | Should -BeTrue
            Test-Path '.github/agents/task-planner.agent.md' | Should -BeTrue
        }

        It 'Copies file content correctly' {
            & $script:scriptPath -HveCoreBasePath $script:sourceRoot -CollectionId 'hve-core' -FilesToCopy @('hve-core/task-researcher.agent.md')

            Get-Content '.github/agents/task-researcher.agent.md' -Raw | Should -Be '# Researcher'
        }

        It 'Skips collision files when keepExisting is true' {
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null
            Set-Content -Path '.github/agents/task-researcher.agent.md' -Value '# Custom' -NoNewline

            & $script:scriptPath -HveCoreBasePath $script:sourceRoot -CollectionId 'hve-core' -FilesToCopy @('hve-core/task-researcher.agent.md') -KeepExisting -Collisions @(Join-Path '.github/agents' 'task-researcher.agent.md')

            Get-Content '.github/agents/task-researcher.agent.md' -Raw | Should -Be '# Custom'
        }

        It 'Overwrites files when keepExisting is false' {
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null
            Set-Content -Path '.github/agents/task-researcher.agent.md' -Value '# Custom' -NoNewline

            & $script:scriptPath -HveCoreBasePath $script:sourceRoot -CollectionId 'hve-core' -FilesToCopy @('hve-core/task-researcher.agent.md')

            Get-Content '.github/agents/task-researcher.agent.md' -Raw | Should -Be '# Researcher'
        }
    }

    Context 'Manifest creation' {
        It 'Creates .hve-tracking.json manifest' {
            & $script:scriptPath -HveCoreBasePath $script:sourceRoot -CollectionId 'hve-core' -FilesToCopy @('hve-core/task-researcher.agent.md')

            Test-Path '.hve-tracking.json' | Should -BeTrue
        }

        It 'Writes correct manifest structure' {
            & $script:scriptPath -HveCoreBasePath $script:sourceRoot -CollectionId 'hve-core' -FilesToCopy @('hve-core/task-researcher.agent.md')

            $manifest = Get-Content '.hve-tracking.json' | ConvertFrom-Json
            $manifest.source | Should -Be 'microsoft/hve-core'
            $manifest.version | Should -Be '2.0.0'
            $manifest.collection | Should -Be 'hve-core'
        }

        It 'Stores SHA256 hashes for copied files' {
            & $script:scriptPath -HveCoreBasePath $script:sourceRoot -CollectionId 'hve-core' -FilesToCopy @('hve-core/task-researcher.agent.md')

            $manifest = Get-Content '.hve-tracking.json' | ConvertFrom-Json -AsHashtable
            $fileEntry = $manifest.files['.github/agents/task-researcher.agent.md']
            $fileEntry | Should -Not -BeNullOrEmpty
            $fileEntry.sha256 | Should -Not -BeNullOrEmpty
            $fileEntry.status | Should -Be 'managed'
        }

        It 'Records correct SHA256 hash matching the file on disk' {
            & $script:scriptPath -HveCoreBasePath $script:sourceRoot -CollectionId 'hve-core' -FilesToCopy @('hve-core/task-researcher.agent.md')

            $manifest = Get-Content '.hve-tracking.json' | ConvertFrom-Json -AsHashtable
            $expectedHash = (Get-FileHash -Path '.github/agents/task-researcher.agent.md' -Algorithm SHA256).Hash.ToLower()
            $manifest.files['.github/agents/task-researcher.agent.md'].sha256 | Should -Be $expectedHash
        }
    }
}

#Requires -Modules Pester
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT

Describe 'collision-detection' -Tag 'Unit' {
    BeforeAll {
        $script:scriptPath = Join-Path $PSScriptRoot '../scripts/collision-detection.ps1'
        $script:testRoot = Join-Path ([System.IO.Path]::GetTempPath()) "hve-test-collision-$([guid]::NewGuid().ToString('N'))"
        $script:sourceRoot = Join-Path $script:testRoot 'source'
    }

    BeforeEach {
        New-Item -ItemType Directory -Path $script:testRoot -Force | Out-Null
        New-Item -ItemType Directory -Path $script:sourceRoot -Force | Out-Null

        # Create source agents
        $agentsDir = Join-Path $script:sourceRoot '.github/agents/hve-core'
        New-Item -ItemType Directory -Path $agentsDir -Force | Out-Null
        Set-Content -Path (Join-Path $agentsDir 'task-researcher.agent.md') -Value '# Researcher'
        Set-Content -Path (Join-Path $agentsDir 'task-planner.agent.md') -Value '# Planner'

        Push-Location $script:testRoot
    }

    AfterEach {
        Pop-Location
    }

    AfterAll {
        if (Test-Path $script:testRoot) {
            Remove-Item $script:testRoot -Recurse -Force -ErrorAction SilentlyContinue
        }
    }

    Context 'No collisions' {
        It 'Reports COLLISIONS_DETECTED=false when target directory does not exist' {
            $output = & $script:scriptPath -Selection 'hve-core' 6>&1 | Out-String

            $output | Should -Match 'COLLISIONS_DETECTED=false'
        }

        It 'Reports COLLISIONS_DETECTED=false when no matching files exist' {
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null
            Set-Content -Path '.github/agents/unrelated.md' -Value '# Other'

            $output = & $script:scriptPath -Selection 'hve-core' 6>&1 | Out-String

            $output | Should -Match 'COLLISIONS_DETECTED=false'
        }
    }

    Context 'Collisions detected' {
        It 'Reports COLLISIONS_DETECTED=true when target files exist' {
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null
            Set-Content -Path '.github/agents/task-researcher.agent.md' -Value '# Existing'

            $output = & $script:scriptPath -Selection 'hve-core' 6>&1 | Out-String

            $output | Should -Match 'COLLISIONS_DETECTED=true'
        }

        It 'Lists collision file paths' {
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null
            Set-Content -Path '.github/agents/task-researcher.agent.md' -Value '# Existing'
            Set-Content -Path '.github/agents/task-planner.agent.md' -Value '# Existing'

            $output = & $script:scriptPath -Selection 'hve-core' 6>&1 | Out-String

            $output | Should -Match 'COLLISION_FILES='
            $output | Should -Match 'task-researcher\.agent\.md'
            $output | Should -Match 'task-planner\.agent\.md'
        }
    }

    Context 'Collection selection' {
        It 'Uses collectionAgents for non-hve-core selection' {
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null
            Set-Content -Path '.github/agents/custom-agent.agent.md' -Value '# Custom'

            $output = & $script:scriptPath -Selection 'my-collection' -CollectionAgents @('my-collection/custom-agent.agent.md') 6>&1 | Out-String

            $output | Should -Match 'COLLISIONS_DETECTED=true'
            $output | Should -Match 'custom-agent\.agent\.md'
        }

        It 'Reports no collisions for empty collectionAgents' {
            $output = & $script:scriptPath -Selection 'my-collection' -CollectionAgents @() 6>&1 | Out-String

            $output | Should -Match 'COLLISIONS_DETECTED=false'
        }
    }
}

#Requires -Modules Pester
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT

Describe 'detect-environment' -Tag 'Unit' {
    BeforeAll {
        $script:scriptPath = Join-Path $PSScriptRoot '../scripts/detect-environment.ps1'
        $script:testRoot = Join-Path ([System.IO.Path]::GetTempPath()) "hve-test-detect-env-$([guid]::NewGuid().ToString('N'))"
    }

    BeforeEach {
        # Clean and recreate temp directory for full isolation between tests
        if (Test-Path $script:testRoot) {
            Remove-Item $script:testRoot -Recurse -Force -ErrorAction SilentlyContinue
        }
        New-Item -ItemType Directory -Path $script:testRoot -Force | Out-Null
        Push-Location $script:testRoot

        # Save and clear environment variables
        $script:savedCodespaces = $env:CODESPACES
        $script:savedRemoteContainers = $env:REMOTE_CONTAINERS
        $env:CODESPACES = $null
        $env:REMOTE_CONTAINERS = $null
    }

    AfterEach {
        Pop-Location
        $env:CODESPACES = $script:savedCodespaces
        $env:REMOTE_CONTAINERS = $script:savedRemoteContainers
    }

    AfterAll {
        if (Test-Path $script:testRoot) {
            Remove-Item $script:testRoot -Recurse -Force -ErrorAction SilentlyContinue
        }
    }

    Context 'Local environment detection' {
        It 'Detects local environment when no container markers are present' {
            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match 'ENV_TYPE=local'
            $output | Should -Match 'IS_CODESPACES=False'
            $output | Should -Match 'IS_DEVCONTAINER=False'
        }
    }

    Context 'Codespaces environment detection' {
        It 'Detects Codespaces when CODESPACES env var is true' {
            $env:CODESPACES = 'true'

            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match 'ENV_TYPE=codespaces'
            $output | Should -Match 'IS_CODESPACES=True'
            $output | Should -Match 'IS_DEVCONTAINER=True'
        }
    }

    Context 'Devcontainer detection' {
        It 'Detects devcontainer when REMOTE_CONTAINERS env var is true' {
            $env:REMOTE_CONTAINERS = 'true'

            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match 'ENV_TYPE=devcontainer'
            $output | Should -Match 'IS_DEVCONTAINER=True'
        }
    }

    Context 'Devcontainer JSON detection' {
        It 'Reports HAS_DEVCONTAINER_JSON=True when file exists' {
            New-Item -ItemType Directory -Path '.devcontainer' -Force | Out-Null
            Set-Content -Path '.devcontainer/devcontainer.json' -Value '{}'

            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match 'HAS_DEVCONTAINER_JSON=True'
        }

        It 'Reports HAS_DEVCONTAINER_JSON=False when file does not exist' {
            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match 'HAS_DEVCONTAINER_JSON=False'
        }
    }

    Context 'Workspace file detection' {
        It 'Reports HAS_WORKSPACE_FILE=True when .code-workspace file exists' {
            Set-Content -Path 'test.code-workspace' -Value '{}'

            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match 'HAS_WORKSPACE_FILE=True'
        }

        It 'Reports HAS_WORKSPACE_FILE=False when no workspace file exists' {
            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match 'HAS_WORKSPACE_FILE=False'
        }
    }

    Context 'HVE-Core repo detection' {
        It 'Reports IS_HVE_CORE_REPO output' {
            # In a temp directory outside a hve-core repo, this should be False
            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match 'IS_HVE_CORE_REPO='
        }
    }
}

#Requires -Modules Pester
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT

Describe 'eject' -Tag 'Unit' {
    BeforeAll {
        $script:scriptPath = Join-Path $PSScriptRoot '../scripts/eject.ps1'
        $script:testRoot = Join-Path ([System.IO.Path]::GetTempPath()) "hve-test-eject-$([guid]::NewGuid().ToString('N'))"
    }

    BeforeEach {
        New-Item -ItemType Directory -Path $script:testRoot -Force | Out-Null
        Push-Location $script:testRoot
    }

    AfterEach {
        Pop-Location
    }

    AfterAll {
        if (Test-Path $script:testRoot) {
            Remove-Item $script:testRoot -Recurse -Force -ErrorAction SilentlyContinue
        }
    }

    Context 'Successful ejection' {
        It 'Sets file status to ejected in manifest' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '1.0.0'
                files = @{
                    '.github/agents/task-implementor.agent.md' = @{
                        version = '1.0.0'
                        sha256 = 'abc123'
                        status = 'managed'
                    }
                }
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            & $script:scriptPath -FilePath '.github/agents/task-implementor.agent.md'

            $updated = Get-Content '.hve-tracking.json' | ConvertFrom-Json -AsHashtable
            $updated.files['.github/agents/task-implementor.agent.md'].status | Should -Be 'ejected'
        }

        It 'Adds ejectedAt timestamp to the file entry' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '1.0.0'
                files = @{
                    '.github/agents/task-implementor.agent.md' = @{
                        version = '1.0.0'
                        sha256 = 'abc123'
                        status = 'managed'
                    }
                }
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            & $script:scriptPath -FilePath '.github/agents/task-implementor.agent.md'

            $updated = Get-Content '.hve-tracking.json' | ConvertFrom-Json -AsHashtable
            $updated.files['.github/agents/task-implementor.agent.md'].ejectedAt | Should -Not -BeNullOrEmpty
        }

        It 'Preserves other files in the manifest' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '1.0.0'
                files = @{
                    '.github/agents/task-implementor.agent.md' = @{
                        version = '1.0.0'
                        sha256 = 'abc123'
                        status = 'managed'
                    }
                    '.github/agents/task-researcher.agent.md' = @{
                        version = '1.0.0'
                        sha256 = 'def456'
                        status = 'managed'
                    }
                }
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            & $script:scriptPath -FilePath '.github/agents/task-implementor.agent.md'

            $updated = Get-Content '.hve-tracking.json' | ConvertFrom-Json -AsHashtable
            $updated.files['.github/agents/task-researcher.agent.md'].status | Should -Be 'managed'
        }
    }

    Context 'File not found in manifest' {
        It 'Outputs error message for untracked file' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '1.0.0'
                files = @{}
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath -FilePath '.github/agents/nonexistent.md' 6>&1 | Out-String

            $output | Should -Match 'not found in tracking manifest'
        }

        It 'Does not modify manifest when file is not tracked' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '1.0.0'
                files = @{
                    '.github/agents/task-implementor.agent.md' = @{
                        version = '1.0.0'
                        sha256 = 'abc123'
                        status = 'managed'
                    }
                }
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            & $script:scriptPath -FilePath '.github/agents/nonexistent.md'

            $updated = Get-Content '.hve-tracking.json' | ConvertFrom-Json -AsHashtable
            $updated.files['.github/agents/task-implementor.agent.md'].status | Should -Be 'managed'
        }
    }

    Context 'Parameter validation' {
        It 'Has a mandatory FilePath parameter' {
            $command = Get-Command $script:scriptPath
            $param = $command.Parameters['FilePath']
            $param | Should -Not -BeNullOrEmpty
            $param.Attributes | Where-Object { $_ -is [System.Management.Automation.ParameterAttribute] -and $_.Mandatory } | Should -Not -BeNullOrEmpty
        }
    }
}

#Requires -Modules Pester
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT

Describe 'file-status-check' -Tag 'Unit' {
    BeforeAll {
        $script:scriptPath = Join-Path $PSScriptRoot '../scripts/file-status-check.ps1'
        $script:testRoot = Join-Path ([System.IO.Path]::GetTempPath()) "hve-test-file-status-$([guid]::NewGuid().ToString('N'))"
    }

    BeforeEach {
        New-Item -ItemType Directory -Path $script:testRoot -Force | Out-Null
        Push-Location $script:testRoot
    }

    AfterEach {
        Pop-Location
    }

    AfterAll {
        if (Test-Path $script:testRoot) {
            Remove-Item $script:testRoot -Recurse -Force -ErrorAction SilentlyContinue
        }
    }

    Context 'Managed files (unchanged)' {
        It 'Reports managed status when file hash matches manifest' {
            $filePath = '.github/agents/task-researcher.agent.md'
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null
            Set-Content -Path $filePath -Value '# Researcher' -NoNewline
            $hash = (Get-FileHash -Path $filePath -Algorithm SHA256).Hash.ToLower()

            $manifest = @{
                files = @{
                    $filePath = @{ sha256 = $hash; status = 'managed' }
                }
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match "FILE=$([regex]::Escape($filePath))\|STATUS=managed\|ACTION=Will update"
        }
    }

    Context 'Modified files' {
        It 'Reports modified status when file hash differs from manifest' {
            $filePath = '.github/agents/task-researcher.agent.md'
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null
            Set-Content -Path $filePath -Value '# Modified Content' -NoNewline

            $manifest = @{
                files = @{
                    $filePath = @{ sha256 = 'old_hash_value'; status = 'managed' }
                }
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match "FILE=$([regex]::Escape($filePath))\|STATUS=modified\|ACTION=Requires decision"
        }
    }

    Context 'Missing files' {
        It 'Reports missing status when tracked file does not exist on disk' {
            $filePath = '.github/agents/missing-file.agent.md'

            $manifest = @{
                files = @{
                    $filePath = @{ sha256 = 'abc123'; status = 'managed' }
                }
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match "FILE=$([regex]::Escape($filePath))\|STATUS=missing\|ACTION=Will restore"
        }
    }

    Context 'Ejected files' {
        It 'Reports ejected status and skip action for ejected files' {
            $filePath = '.github/agents/custom.agent.md'
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null
            Set-Content -Path $filePath -Value '# Custom' -NoNewline

            $manifest = @{
                files = @{
                    $filePath = @{
                        sha256 = 'abc123'
                        status = 'ejected'
                        ejectedAt = '2025-01-01T00:00:00Z'
                    }
                }
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match "FILE=$([regex]::Escape($filePath))\|STATUS=ejected\|ACTION=Skip"
        }

        It 'Does not check hash for ejected files' {
            $filePath = '.github/agents/ejected.agent.md'
            # File does not exist on disk, but ejected files should not be hash-checked
            $manifest = @{
                files = @{
                    $filePath = @{
                        sha256 = 'abc123'
                        status = 'ejected'
                        ejectedAt = '2025-01-01T00:00:00Z'
                    }
                }
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath 6>&1 | Out-String

            # Should report ejected, not missing
            $output | Should -Match 'STATUS=ejected'
            $output | Should -Not -Match 'STATUS=missing'
        }
    }

    Context 'Multiple files' {
        It 'Reports status for each tracked file independently' {
            New-Item -ItemType Directory -Path '.github/agents' -Force | Out-Null

            $managedPath = '.github/agents/managed.agent.md'
            Set-Content -Path $managedPath -Value '# Managed' -NoNewline
            $managedHash = (Get-FileHash -Path $managedPath -Algorithm SHA256).Hash.ToLower()

            $modifiedPath = '.github/agents/modified.agent.md'
            Set-Content -Path $modifiedPath -Value '# Modified' -NoNewline

            $missingPath = '.github/agents/missing.agent.md'

            $manifest = @{
                files = @{
                    $managedPath  = @{ sha256 = $managedHash; status = 'managed' }
                    $modifiedPath = @{ sha256 = 'wrong_hash'; status = 'managed' }
                    $missingPath  = @{ sha256 = 'abc123'; status = 'managed' }
                }
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath 6>&1 | Out-String

            $output | Should -Match 'STATUS=managed'
            $output | Should -Match 'STATUS=modified'
            $output | Should -Match 'STATUS=missing'
        }
    }
}

#Requires -Modules Pester
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT

Describe 'upgrade-detection' -Tag 'Unit' {
    BeforeAll {
        $script:scriptPath = Join-Path $PSScriptRoot '../scripts/upgrade-detection.ps1'
        $script:testRoot = Join-Path ([System.IO.Path]::GetTempPath()) "hve-test-upgrade-$([guid]::NewGuid().ToString('N'))"
        $script:sourceRoot = Join-Path $script:testRoot 'source'
    }

    BeforeEach {
        New-Item -ItemType Directory -Path $script:testRoot -Force | Out-Null
        New-Item -ItemType Directory -Path $script:sourceRoot -Force | Out-Null
        Push-Location $script:testRoot
    }

    AfterEach {
        Pop-Location
    }

    AfterAll {
        if (Test-Path $script:testRoot) {
            Remove-Item $script:testRoot -Recurse -Force -ErrorAction SilentlyContinue
        }
    }

    Context 'Fresh installation (no manifest)' {
        It 'Reports UPGRADE_MODE=false when no manifest exists' {
            $output = & $script:scriptPath -HveCoreBasePath $script:sourceRoot 6>&1 | Out-String

            $output | Should -Match 'UPGRADE_MODE=false'
        }
    }

    Context 'Existing installation' {
        BeforeEach {
            @{ version = '2.0.0' } | ConvertTo-Json | Set-Content (Join-Path $script:sourceRoot 'package.json')
        }

        It 'Reports UPGRADE_MODE=true when manifest exists' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '1.0.0'
                collection = 'hve-core'
                files = @{}
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath -HveCoreBasePath $script:sourceRoot 6>&1 | Out-String

            $output | Should -Match 'UPGRADE_MODE=true'
        }

        It 'Reports installed and source versions' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '1.0.0'
                collection = 'hve-core'
                files = @{}
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath -HveCoreBasePath $script:sourceRoot 6>&1 | Out-String

            $output | Should -Match 'INSTALLED_VERSION=1\.0\.0'
            $output | Should -Match 'SOURCE_VERSION=2\.0\.0'
        }

        It 'Reports VERSION_CHANGED=True when versions differ' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '1.0.0'
                collection = 'hve-core'
                files = @{}
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath -HveCoreBasePath $script:sourceRoot 6>&1 | Out-String

            $output | Should -Match 'VERSION_CHANGED=True'
        }

        It 'Reports VERSION_CHANGED=False when versions match' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '2.0.0'
                collection = 'hve-core'
                files = @{}
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath -HveCoreBasePath $script:sourceRoot 6>&1 | Out-String

            $output | Should -Match 'VERSION_CHANGED=False'
        }

        It 'Reports INSTALLED_COLLECTION from manifest' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '1.0.0'
                collection = 'developer'
                files = @{}
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath -HveCoreBasePath $script:sourceRoot 6>&1 | Out-String

            $output | Should -Match 'INSTALLED_COLLECTION=developer'
        }

        It 'Defaults INSTALLED_COLLECTION to hve-core when not set in manifest' {
            $manifest = @{
                source = 'microsoft/hve-core'
                version = '1.0.0'
                files = @{}
            }
            $manifest | ConvertTo-Json -Depth 10 | Set-Content '.hve-tracking.json'

            $output = & $script:scriptPath -HveCoreBasePath $script:sourceRoot 6>&1 | Out-String

            $output | Should -Match 'INSTALLED_COLLECTION=hve-core'
        }
    }
}

#Requires -Modules Pester
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT

Describe 'validate-extension' -Tag 'Unit' {
    BeforeAll {
        $script:scriptPath = Join-Path $PSScriptRoot '../scripts/validate-extension.ps1'
        $script:testRoot = Join-Path ([System.IO.Path]::GetTempPath()) "hve-test-valext-$([guid]::NewGuid().ToString('N'))"
        New-Item -ItemType Directory -Path $script:testRoot -Force | Out-Null
    }

    AfterAll {
        if (Test-Path $script:testRoot) {
            Remove-Item $script:testRoot -Recurse -Force -ErrorAction SilentlyContinue
        }
    }

    Context 'Extension installed' {
        It 'Reports EXTENSION_INSTALLED=True when extension is listed' {
            # Create a mock script that simulates the code CLI
            $mockPath = Join-Path $script:testRoot 'mock-code-found.ps1'
            @'
if ($args -contains '--show-versions') {
    'ms-vscode.powershell@2024.1.0'
    'ise-hve-essentials.hve-core@3.0.2'
    'github.copilot@1.0.0'
} else {
    'ms-vscode.powershell'
    'ise-hve-essentials.hve-core'
    'github.copilot'
}
'@ | Set-Content $mockPath

            $output = & $script:scriptPath -CodeCli $mockPath 6>&1 | Out-String

            $output | Should -Match 'EXTENSION_INSTALLED=True'
        }

        It 'Reports extension version when available' {
            $mockPath = Join-Path $script:testRoot 'mock-code-version.ps1'
            @'
if ($args -contains '--show-versions') {
    'ise-hve-essentials.hve-core@3.0.2'
} else {
    'ise-hve-essentials.hve-core'
}
'@ | Set-Content $mockPath

            $output = & $script:scriptPath -CodeCli $mockPath 6>&1 | Out-String

            $output | Should -Match '3\.0\.2'
        }
    }

    Context 'Extension not installed' {
        It 'Reports EXTENSION_INSTALLED=False when extension is not listed' {
            $mockPath = Join-Path $script:testRoot 'mock-code-notfound.ps1'
            @'
'ms-vscode.powershell'
'github.copilot'
'@ | Set-Content $mockPath

            $output = & $script:scriptPath -CodeCli $mockPath 6>&1 | Out-String

            $output | Should -Match 'EXTENSION_INSTALLED=False'
        }
    }

    Context 'Default codeCli' {
        It 'Has a default value for CodeCli parameter' {
            $param = (Get-Command $script:scriptPath).Parameters['CodeCli']
            $param | Should -Not -BeNullOrEmpty
            $param.Attributes | Where-Object { $_ -is [System.Management.Automation.ParameterAttribute] } | Should -Not -BeNullOrEmpty
        }
    }
}

#Requires -Modules Pester
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: MIT

Describe 'validate-installation' -Tag 'Unit' {
    BeforeAll {
        $script:scriptPath = Join-Path $PSScriptRoot '../scripts/validate-installation.ps1'
        $script:testRoot = Join-Path ([System.IO.Path]::GetTempPath()) "hve-test-validate-$([guid]::NewGuid().ToString('N'))"
    }

    BeforeEach {
        New-Item -ItemType Directory -Path $script:testRoot -Force | Out-Null
        Push-Location $script:testRoot
    }

    AfterEach {
        Pop-Location
    }

    AfterAll {
        if (Test-Path $script:testRoot) {
            Remove-Item $script:testRoot -Recurse -Force -ErrorAction SilentlyContinue
        }
    }

    Context 'Parameter validation' {
        It 'Has a mandatory BasePath parameter' {
            $param = (Get-Command $script:scriptPath).Parameters['BasePath']
            $param | Should -Not -BeNullOrEmpty
            $attr = $param.Attributes | Where-Object { $_ -is [System.Management.Automation.ParameterAttribute] }
            $attr.Mandatory | Should -BeTrue
        }

        It 'Has a mandatory Method parameter' {
            $param = (Get-Command $script:scriptPath).Parameters['Method']
            $param | Should -Not -BeNullOrEmpty
            $attr = $param.Attributes | Where-Object { $_ -is [System.Management.Automation.ParameterAttribute] }
            $attr.Mandatory | Should -BeTrue
        }
    }

    Context 'Directory validation' {
        It 'Passes when all required directories exist' {
            $installDir = Join-Path $script:testRoot 'install'
            foreach ($dir in @('.github/agents', '.github/prompts', '.github/instructions', '.github/skills')) {
                New-Item -ItemType Directory -Path (Join-Path $installDir $dir) -Force | Out-Null
            }

            $output = & $script:scriptPath -BasePath $installDir -Method 1 6>&1 | Out-String

            $output | Should -Match 'Installation validated successfully'
        }

        It 'Reports missing directories' {
            $installDir = Join-Path $script:testRoot 'empty-install'
            New-Item -ItemType Directory -Path $installDir -Force | Out-Null

            $output = & $script:scriptPath -BasePath $installDir -Method 1 6>&1 | Out-String

            $output | Should -Match 'Missing'
        }

        It 'Checks agents directory' {
            $installDir = Join-Path $script:testRoot 'partial'
            New-Item -ItemType Directory -Path (Join-Path $installDir '.github/prompts') -Force | Out-Null
            New-Item -ItemType Directory -Path (Join-Path $installDir '.github/instructions') -Force | Out-Null
            New-Item -ItemType Directory -Path (Join-Path $installDir '.github/skills') -Force | Out-Null

            $output = & $script:scriptPath -BasePath $installDir -Method 1 6>&1 | Out-String

            $output | Should -Match '(?s)Missing.*agents'
        }

        It 'Checks skills directory' {
            $installDir = Join-Path $script:testRoot 'no-skills'
            New-Item -ItemType Directory -Path (Join-Path $installDir '.github/agents') -Force | Out-Null
            New-Item -ItemType Directory -Path (Join-Path $installDir '.github/prompts') -Force | Out-Null
            New-Item -ItemType Directory -Path (Join-Path $installDir '.github/instructions') -Force | Out-Null

            $output = & $script:scriptPath -BasePath $installDir -Method 1 6>&1 | Out-String

            $output | Should -Match '(?s)Missing.*skills'
        }
    }

    Context 'Experimental subdirectories' {
        It 'Passes validation when experimental directories are absent' {
            $installDir = Join-Path $script:testRoot 'no-experimental'
            foreach ($dir in @('.github/agents', '.github/prompts', '.github/instructions', '.github/skills')) {
                New-Item -ItemType Directory -Path (Join-Path $installDir $dir) -Force | Out-Null
            }

            $output = & $script:scriptPath -BasePath $installDir -Method 1 6>&1 | Out-String

            $LASTEXITCODE | Should -Not -Be 1
            $output | Should -Match 'Installation validated successfully'
            $output | Should -Not -Match 'Missing.*experimental'
        }

        It 'Reports optional experimental directories when present' {
            $installDir = Join-Path $script:testRoot 'with-experimental'
            foreach ($dir in @('.github/agents', '.github/prompts', '.github/instructions', '.github/skills',
                               '.github/skills/experimental', '.github/agents/experimental')) {
                New-Item -ItemType Directory -Path (Join-Path $installDir $dir) -Force | Out-Null
            }

            $output = & $script:scriptPath -BasePath $installDir -Method 1 6>&1 | Out-String

            $output | Should -Match '(?s)Found optional.*skills/experimental'
            $output | Should -Match '(?s)Found optional.*agents/experimental'
            $output | Should -Match 'Installation validated successfully'
        }
    }

    Context 'Method 5: Multi-root workspace validation' {
        It 'Validates multi-root workspace configuration' {
            $installDir = Join-Path $script:testRoot 'method5'
            foreach ($dir in @('.github/agents', '.github/prompts', '.github/instructions', '.github/skills')) {
                New-Item -ItemType Directory -Path (Join-Path $installDir $dir) -Force | Out-Null
            }

            $workspace = @{
                folders = @(
                    @{ path = '.' }
                    @{ path = 'lib/hve-core' }
                )
            }
            $workspace | ConvertTo-Json -Depth 5 | Set-Content 'hve-core.code-workspace'

            $output = & $script:scriptPath -BasePath $installDir -Method 5 6>&1 | Out-String

            $output | Should -Match 'Multi-root configured'
        }

        It 'Fails multi-root check when workspace has fewer than 2 folders' {
            $installDir = Join-Path $script:testRoot 'method5-bad'
            foreach ($dir in @('.github/agents', '.github/prompts', '.github/instructions', '.github/skills')) {
                New-Item -ItemType Directory -Path (Join-Path $installDir $dir) -Force | Out-Null
            }

            $workspace = @{
                folders = @(
                    @{ path = '.' }
                )
            }
            $workspace | ConvertTo-Json -Depth 5 | Set-Content 'hve-core.code-workspace'

            $output = & $script:scriptPath -BasePath $installDir -Method 5 6>&1 | Out-String

            $output | Should -Match 'Multi-root not configured'
        }
    }

    Context 'Method 6: Submodule validation' {
        It 'Validates submodule entry in .gitmodules' {
            $installDir = Join-Path $script:testRoot 'method6'
            foreach ($dir in @('.github/agents', '.github/prompts', '.github/instructions', '.github/skills')) {
                New-Item -ItemType Directory -Path (Join-Path $installDir $dir) -Force | Out-Null
            }

            @'
[submodule "lib/hve-core"]
    path = lib/hve-core
    url = https://github.com/microsoft/hve-core.git
'@ | Set-Content '.gitmodules'

            $output = & $script:scriptPath -BasePath $installDir -Method 6 6>&1 | Out-String

            $output | Should -Not -Match 'Submodule not in .gitmodules'
        }

        It 'Fails when .gitmodules missing submodule entry' {
            $installDir = Join-Path $script:testRoot 'method6-bad'
            foreach ($dir in @('.github/agents', '.github/prompts', '.github/instructions', '.github/skills')) {
                New-Item -ItemType Directory -Path (Join-Path $installDir $dir) -Force | Out-Null
            }

            Set-Content '.gitmodules' -Value '[submodule "other"]'

            $output = & $script:scriptPath -BasePath $installDir -Method 6 6>&1 | Out-String

            $output | Should -Match 'Submodule not in .gitmodules'
        }

        It 'Fails when .gitmodules does not exist' {
            $installDir = Join-Path $script:testRoot 'method6-nomod'
            foreach ($dir in @('.github/agents', '.github/prompts', '.github/instructions', '.github/skills')) {
                New-Item -ItemType Directory -Path (Join-Path $installDir $dir) -Force | Out-Null
            }

            # Ensure .gitmodules does not exist
            Remove-Item '.gitmodules' -ErrorAction SilentlyContinue

            $output = & $script:scriptPath -BasePath $installDir -Method 6 6>&1 | Out-String

            $output | Should -Match 'Submodule not in .gitmodules'
        }
    }

    Context 'Standard methods (1-4)' {
        It 'Passes validation for method 1 with all directories' {
            $installDir = Join-Path $script:testRoot 'method1'
            foreach ($dir in @('.github/agents', '.github/prompts', '.github/instructions', '.github/skills')) {
                New-Item -ItemType Directory -Path (Join-Path $installDir $dir) -Force | Out-Null
            }

            $output = & $script:scriptPath -BasePath $installDir -Method 1 6>&1 | Out-String

            $output | Should -Match 'Installation validated successfully'
        }
    }
}