How to Generate a Project Folder Structure in Visual Studio Code (Step-by-Step)

Sometimes you need more than just a directory tree—you want to peek inside each file to review key snippets, share examples, or onboard teammates with both structure and content in one place. That’s exactly what this extended feature gives you:

Why it’s useful

• Code reviews & audits: Quickly scan important sections without opening dozens of editors.

• Documentation snapshots: Capture both where files live and what they contain at a given moment.

• Onboarding & sharing: New collaborators get a single text-based overview and code preview.

How to activate it

1. 1. Open your existing generate-structure.ps1 in VS Code (or your editor of choice).

   2. Replace its entire contents with this updated script (which now writes a PLUGIN FILE PATH : … banner before each file’s content):
      powershellCopy

      param(
          [string]$RootPath    = ".",
          [string]$OutputFile  = "project-structure.txt",
          [string[]]$Skip      = @(),
          [string[]]$SkipTypes = @()
      )
      
      # Always skip the output file itself to avoid write-lock errors
      $Skip += (Split-Path $OutputFile -Leaf)
      
      # Resolve full paths
      $fullRootPath = (Get-Item $RootPath).FullName
      # Normalize and remove any trailing slashes or backslashes
      $rootFull     = $fullRootPath -replace '[\\/]+$',''
      $outputFull   = Join-Path $rootFull $OutputFile
      
      function Should-Skip {
          param([string]$Path)
          foreach ($pattern in $Skip) {
              if ($Path -like "*$pattern*") { return $true }
          }
          return $false
      }
      
      function Show-Tree {
          param(
              [string]$Path,
              [string]$Prefix
          )
          Get-ChildItem -LiteralPath $Path |
            Sort-Object { -not $_.PSIsContainer }, Name |
            ForEach-Object {
              $item     = $_
              $full     = $item.FullName
              $relative = if ($full.Length -gt $rootFull.Length) {
                              $full.Substring($rootFull.Length + 1)
                          } else {
                              $item.Name
                          }
              if (Should-Skip $relative) { return }
      
              $line = "$Prefix|-- $($item.Name)"
              Add-Content -Path $outputFull -Value $line
      
              if ($item.PSIsContainer) {
                  Show-Tree -Path $full -Prefix "$Prefix|   "
              }
          }
      }
      
      function Show-Files {
          param([string]$Path)
          Get-ChildItem -LiteralPath $Path | ForEach-Object {
              $item     = $_
              $full     = $item.FullName
              if ($full -eq $outputFull) { return }
              $relative = if ($full.Length -gt $rootFull.Length) {
                              $full.Substring($rootFull.Length + 1)
                          } else {
                              $item.Name
                          }
              if (Should-Skip $relative) { return }
      
              if ($item.PSIsContainer) {
                  Show-Files -Path $full
              } else {
                  $ext = $item.Extension.TrimStart('.').ToLower()
                  if ($SkipTypes -contains $ext) { return }
      
                  Add-Content -Path $outputFull -Value "---------------------------------------------------------------------------"
                  Add-Content -Path $outputFull -Value "PLUGIN FILE PATH : $relative"
                  Add-Content -Path $outputFull -Value "---------------------------------------------------------------------------"
                  Get-Content -Path $full | ForEach-Object {
                      Add-Content -Path $outputFull -Value $_
                  }
              }
          }
      }
      
      # Remove previous output
      if (Test-Path $outputFull) { Remove-Item $outputFull }
      
      # Write header and build
      Add-Content -Path $outputFull -Value (Split-Path -Leaf (Get-Item $RootPath))
      Show-Tree  -Path $RootPath -Prefix ""
      Show-Files -Path $RootPath
      
      Write-Output "Structure and file contents written to '$OutputFile'."
      

   3. Save the file.
   4. Run the updated script using the new -Skip flag to omit both folders, files and file extension. For example, to skip your vendor/ directory and any readme.txt files along with .txt and .xml file types.
      powershellCopy

      .\generate-structure.ps1 -Skip "vendor","readme.txt" -SkipTypes "xml","txt"

      You’ll now get both the folder tree and, for each file, a section like:
      powershellCopy

      elementrix-elementor-addons
      |-- admin
      | |-- admin-interface.php
      | |-- class-admin-notices.php
      | |-- class-admin-settings.php
      |-- assets
      | |-- css
      | |-- images
      | |-- js
      |-- controls
      | |-- test-control.php
      |-- includes
      | |-- api
      | |-- class-loader.php
      | |-- class-plugin.php
      |-- languages
      |-- widgets
      | |-- test-widget.php
      |-- elementrix-elementor-addons.php
      |-- generate-structure.ps1
      |-- project-structure.txt
      |-- README.txt 
      
      -----------------------------------------------------------------
      PLUGIN FILE PATH : admin\admin-interface.php
      -----------------------------------------------------------------
      // (followed by the file’s actual contents)
      

      This will:

      • Exclude the specified folders and files from your folder tree.

      • Skip them along with the specified file types when dumping file contents under their “PLUGIN FILE PATH” banners.