Apex Decompose

# APEX Decompose — Dependency Scanner (Windows)
# Scans a source directory and outputs a dependency report.
# Usage: powershell -File scan-deps.ps1 <source-dir>

param(
    [Parameter(Position=0)]
    [string]$SourceDir = "."
)

$ErrorActionPreference = "Stop"

if (-not (Test-Path $SourceDir -PathType Container)) {
    Write-Error "ERROR: Directory '$SourceDir' does not exist."
    exit 1
}

Write-Host "=== APEX Dependency Scan ==="
Write-Host "Source: $SourceDir"
Write-Host "Date: $((Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ'))"
Write-Host ""

# Detect project type
Write-Host "--- Project Detection ---"
$packageJson = Join-Path $SourceDir "package.json"
$requirementsTxt = Join-Path $SourceDir "requirements.txt"
$pyprojectToml = Join-Path $SourceDir "pyproject.toml"
$goMod = Join-Path $SourceDir "go.mod"
$cargoToml = Join-Path $SourceDir "Cargo.toml"

if (Test-Path $packageJson) {
    Write-Host "Type: Node.js / JavaScript / TypeScript"
    $pm = if (Test-Path (Join-Path $SourceDir "pnpm-lock.yaml")) { "pnpm" }
          elseif (Test-Path (Join-Path $SourceDir "yarn.lock")) { "yarn" }
          else { "npm" }
    Write-Host "Package Manager: $pm"
    Write-Host ""
    Write-Host "--- Dependencies (package.json) ---"
    try {
        $pkg = Get-Content $packageJson -Raw | ConvertFrom-Json
        if ($pkg.dependencies) {
            $pkg.dependencies.PSObject.Properties | ForEach-Object {
                Write-Host "  $($_.Name): $($_.Value)"
            }
        }
        Write-Host ""
        Write-Host "--- Dev Dependencies ---"
        if ($pkg.devDependencies) {
            $pkg.devDependencies.PSObject.Properties | ForEach-Object {
                Write-Host "  $($_.Name): $($_.Value)"
            }
        }
    } catch {
        Write-Host "  (could not parse)"
    }
} elseif ((Test-Path $requirementsTxt) -or (Test-Path $pyprojectToml)) {
    Write-Host "Type: Python"
    Write-Host ""
    Write-Host "--- Dependencies ---"
    if (Test-Path $requirementsTxt) { Get-Content $requirementsTxt }
    if (Test-Path $pyprojectToml) { Get-Content $pyprojectToml }
} elseif (Test-Path $goMod) {
    Write-Host "Type: Go"
    Write-Host ""
    Write-Host "--- Dependencies (go.mod) ---"
    Get-Content $goMod
} elseif (Test-Path $cargoToml) {
    Write-Host "Type: Rust"
    Write-Host ""
    Write-Host "--- Dependencies (Cargo.toml) ---"
    Get-Content $cargoToml
} else {
    Write-Host "Type: Unknown (no recognized package manifest found)"
}

Write-Host ""
Write-Host "--- File Structure ---"
Get-ChildItem -Path $SourceDir -Recurse -File |
    Where-Object {
        $_.FullName -notmatch "node_modules|\.git|dist|build|__pycache__|target" -and
        $_.Name -notmatch "\.lock$|package-lock\.json$"
    } |
    Select-Object -First 200 |
    Sort-Object FullName |
    ForEach-Object { $_.FullName.Replace($SourceDir, ".") }

Write-Host ""
Write-Host "--- Import/Require Analysis ---"

# JavaScript/TypeScript imports
$jsFiles = Get-ChildItem -Path $SourceDir -Recurse -Include "*.ts","*.tsx","*.js","*.jsx" -File |
    Where-Object { $_.FullName -notmatch "node_modules" }
foreach ($file in ($jsFiles | Select-Object -First 50)) {
    $imports = Select-String -Path $file.FullName -Pattern "^import|^const.*require\(" -ErrorAction SilentlyContinue
    if ($imports) { $imports | Select-Object -First 5 | ForEach-Object { Write-Host $_.ToString() } }
}

# Python imports
$pyFiles = Get-ChildItem -Path $SourceDir -Recurse -Include "*.py" -File |
    Where-Object { $_.FullName -notmatch "__pycache__" }
foreach ($file in ($pyFiles | Select-Object -First 50)) {
    $imports = Select-String -Path $file.FullName -Pattern "^import|^from.*import" -ErrorAction SilentlyContinue
    if ($imports) { $imports | Select-Object -First 5 | ForEach-Object { Write-Host $_.ToString() } }
}

Write-Host ""
Write-Host "=== Scan Complete ==="

#!/usr/bin/env bash
# APEX Decompose — Dependency Scanner (Linux/Mac)
# Scans a source directory and outputs a dependency report.
# Usage: bash scan-deps.sh <source-dir>

set -euo pipefail

SOURCE_DIR="${1:-.}"

if [ ! -d "$SOURCE_DIR" ]; then
  echo "ERROR: Directory '$SOURCE_DIR' does not exist."
  exit 1
fi

echo "=== APEX Dependency Scan ==="
echo "Source: $SOURCE_DIR"
echo "Date: $(date -u +"%Y-%m-%dT%H:%M:%SZ")"
echo ""

# Detect project type
echo "--- Project Detection ---"
if [ -f "$SOURCE_DIR/package.json" ]; then
  echo "Type: Node.js / JavaScript / TypeScript"
  echo "Package Manager: $([ -f "$SOURCE_DIR/pnpm-lock.yaml" ] && echo "pnpm" || ([ -f "$SOURCE_DIR/yarn.lock" ] && echo "yarn" || echo "npm"))"
  echo ""
  echo "--- Dependencies (package.json) ---"
  if command -v jq &>/dev/null; then
    jq -r '.dependencies // {} | to_entries[] | "  \(.key): \(.value)"' "$SOURCE_DIR/package.json" 2>/dev/null || echo "  (could not parse)"
    echo ""
    echo "--- Dev Dependencies ---"
    jq -r '.devDependencies // {} | to_entries[] | "  \(.key): \(.value)"' "$SOURCE_DIR/package.json" 2>/dev/null || echo "  (could not parse)"
  else
    cat "$SOURCE_DIR/package.json"
  fi
elif [ -f "$SOURCE_DIR/requirements.txt" ] || [ -f "$SOURCE_DIR/pyproject.toml" ]; then
  echo "Type: Python"
  echo ""
  echo "--- Dependencies ---"
  [ -f "$SOURCE_DIR/requirements.txt" ] && cat "$SOURCE_DIR/requirements.txt"
  [ -f "$SOURCE_DIR/pyproject.toml" ] && grep -A 50 '\[project.dependencies\]' "$SOURCE_DIR/pyproject.toml" 2>/dev/null || true
elif [ -f "$SOURCE_DIR/go.mod" ]; then
  echo "Type: Go"
  echo ""
  echo "--- Dependencies (go.mod) ---"
  cat "$SOURCE_DIR/go.mod"
elif [ -f "$SOURCE_DIR/Cargo.toml" ]; then
  echo "Type: Rust"
  echo ""
  echo "--- Dependencies (Cargo.toml) ---"
  grep -A 100 '\[dependencies\]' "$SOURCE_DIR/Cargo.toml" 2>/dev/null || cat "$SOURCE_DIR/Cargo.toml"
else
  echo "Type: Unknown (no recognized package manifest found)"
fi

echo ""
echo "--- File Structure ---"
find "$SOURCE_DIR" -type f \
  -not -path "*/node_modules/*" \
  -not -path "*/.git/*" \
  -not -path "*/dist/*" \
  -not -path "*/build/*" \
  -not -path "*/__pycache__/*" \
  -not -path "*/target/*" \
  -not -name "*.lock" \
  -not -name "package-lock.json" \
  | head -200 \
  | sort

echo ""
echo "--- Import/Require Analysis ---"
# JavaScript/TypeScript imports
JS_IMPORTS=$(grep -rn "^import\|^const.*require(" "$SOURCE_DIR" \
  --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" \
  2>/dev/null | grep -v node_modules | head -100)

# Python imports
PY_IMPORTS=$(grep -rn "^import\|^from.*import" "$SOURCE_DIR" \
  --include="*.py" \
  2>/dev/null | grep -v __pycache__ | head -100)

# Go imports
GO_IMPORTS=$(grep -rn "\".*\"" "$SOURCE_DIR" \
  --include="*.go" \
  2>/dev/null | grep -v vendor | head -100)

[ -n "$JS_IMPORTS" ] && echo "$JS_IMPORTS"
[ -n "$PY_IMPORTS" ] && echo "$PY_IMPORTS"
[ -n "$GO_IMPORTS" ] && echo "$GO_IMPORTS"

echo ""
echo "=== Scan Complete ==="