How to efficiently test whether a .PS1 script is a "module" of functions or a normal script?

My organization has a ton of PowerShell scripts. Some of those are straight scripts that process logic/perform certain actions, but others are essentially "modules" (but not actual modules), in that they only contain common function we use which are imported and used by other scripts.

I'm trying to figure out a way to determine if a .PS1 file is a "script", or if it's a "module" in that it only contains functions and doesn't process any logic.

My thoughts are I'd just capture the contents of the script and see if it contains only one or more of: function X { * }, and nothing else. Probably using regex to match that pattern.

But that seems messy, so I was wondering if anyone had any ideas how I can do it better?

I know I'll probably get some people recommending we build modules the way PowerShell intended, but these are all pre-existing scripts that have already been developed and I certainly don't have the authority to tell my entire organization to change the way they write scripts.

> My thoughts are I'd just capture the contents of the script and see if it contains only one or more of: function X { * }, and nothing else.

That's a great plan!

> [...] Probably using regex to match that pattern.

That's a terrible plan!

Instead of regex, use PowerShell's own parser to parse the existing scripts:

using namespace System.Management.Automation.Language

# start by enumerating all the script files in scope
$results = Get-ChildItem folder\with\script\files -Filter *.ps1 -Recurse |ForEach-Object {
  # construct an object that will hold the output for each file analyzed
  $result = [pscustomobject]@{
    Name          = $_.Name
    Path          = $_.FullName
    FunctionCount = 0
    PipelineCount = 0
    OtherCount    = 0
    HadErrors     = $false
  }

  try {
    # attempt to parse the script file
    $scriptAst = [Parser]::ParseFile($_.FullName, [ref]$null, [ref]$null)

    # inspect the top-level statements in the resulting AST, capture the counts of particularly interesting syntax elements
    $result.FunctionCount = $scriptAst.EndBlock.Statements.Where({$_ -is [FunctionDefinitionAst]}).Count
    $result.PipelineCount = $scriptAst.EndBlock.Statements.Where({$_ -is [PipelineAst]}).Count
    $result.OtherCount    = $scriptAst.EndBlock.Statements.Where({$_ -isnot [PipelineAst] -and $_ -isnot [FunctionDefinitionAst]}).Count
  }
  catch {
    # in case of failure we want to report that to the caller
    $result.HadErrors = $true
  }

  # output the details captured
  $result
}

Now that we've analyzed the top-level statements in all the scripts, we can start filtering them based on the expectation that most are probably "module-like":

$results |Where-Object { $_.FunctionCount -gt 0 -and $_.PipelineCount -eq 0 } |ForEach-Object {
    Write-Host "Script at '$($_.Path)' looks like a module! No pipelines, just functions!"
}