@danmoisan/drm-copilot-mcp 1.1.16 → 1.1.17

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadiusConflict.psm1

@@ -190,6 +190,182 @@ function Get-NonMergeablePathEntry {
     return @(Get-OrdinalSortedEntry -Entry $survivor.ToArray())
 }
 
+function ConvertTo-PathOverlapRecord {
+    <#
+    .SYNOPSIS
+        Precompute the per-entry facts the pairwise overlap decision reads.
+
+    .DESCRIPTION
+        Called once per path collection by Get-OverlappingPathPair (issue #776),
+        so the advanced-function calls made here are linear in the collection
+        size rather than quadratic in the number of pairs.
+
+    .PARAMETER Entry
+        Radius path entries. An empty collection and empty strings are accepted.
+
+    .OUTPUTS
+        System.Object[]. One hashtable record per entry, in input order, with
+        keys Entry, IsGlob, Prefix (the literal prefix of a glob entry, $null for
+        a concrete entry), and Directory (the entry anchored with one trailing
+        separator).
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [AllowEmptyString()]
+        [string[]] $Entry
+    )
+
+    $record = [System.Collections.Generic.List[hashtable]]::new()
+    foreach ($single in $Entry) {
+        $isGlob = Test-GlobEntry -Entry $single
+        $prefix = if ($isGlob) { Get-LiteralPrefix -Entry $single } else { $null }
+        $record.Add(@{
+                Entry     = $single
+                IsGlob    = $isGlob
+                Prefix    = $prefix
+                Directory = $single.TrimEnd('/') + '/'
+            })
+    }
+
+    return @($record.ToArray())
+}
+
+# The one record-form overlap decision (issue #776); its four cases reproduce
+# Test-EntryOverlap exactly (parity guard: BlastRadiusConflict.PathOverlap.Tests.ps1).
+# A simple function because it runs per candidate pair (see Get-GlobRegex).
+function Test-PathOverlapRecordPair {
+    param([hashtable] $Left, [hashtable] $Right)
+
+    $ordinal = [System.StringComparison]::Ordinal
+    if (-not $Left.IsGlob -and -not $Right.IsGlob) {
+        # Two concrete entries: equality or either anchored directory prefix.
+        return ([string]::Equals($Left.Entry, $Right.Entry, $ordinal) -or
+            $Left.Entry.StartsWith($Right.Directory, $ordinal) -or
+            $Right.Entry.StartsWith($Left.Directory, $ordinal))
+    }
+    if ($Left.IsGlob -and -not $Right.IsGlob) {
+        # Glob and concrete: the two literal nest tests, then the pattern match.
+        return ($Left.Prefix.StartsWith($Right.Directory, $ordinal) -or
+            $Right.Directory.StartsWith($Left.Prefix, $ordinal) -or
+            (Test-GlobMatch -Pattern $Left.Entry -Candidate $Right.Entry))
+    }
+    if ($Right.IsGlob -and -not $Left.IsGlob) {
+        return ($Right.Prefix.StartsWith($Left.Directory, $ordinal) -or
+            $Left.Directory.StartsWith($Right.Prefix, $ordinal) -or
+            (Test-GlobMatch -Pattern $Right.Entry -Candidate $Left.Entry))
+    }
+    # Two globs: either literal prefix nests the other.
+    return ($Left.Prefix.StartsWith($Right.Prefix, $ordinal) -or
+        $Right.Prefix.StartsWith($Left.Prefix, $ordinal))
+}
+
+function Get-OverlappingPathPair {
+    <#
+    .SYNOPSIS
+        Return every overlapping path pair of two collections, in nested-loop order.
+
+    .DESCRIPTION
+        Yields exactly the pairs for which Test-EntryOverlap holds without
+        evaluating all |PathA| x |PathB| pairs (issue #776). Concrete pairs, almost
+        all pairs in practice, are found by dictionary lookup: equality against
+        the concrete entries of the other side, and anchored-directory
+        containment, because X.StartsWith(Y.TrimEnd('/') + '/') holds exactly
+        when X[k] is '/' and X.Substring(0, k) equals Y.TrimEnd('/') for some k
+        over the positions of '/' in X, so one lookup per separator position of X
+        decides it (probed in both directions). Every glob-involving pair is
+        decided by Test-PathOverlapRecordPair against the other collection.
+
+        Ordering contract: each pair is recorded once under the key
+        i * |PathB| + j and emitted in ascending key order, which is nested-loop
+        order (outer over PathA, inner over PathB, both in input order). Pairs are
+        never reordered by value; a repeated entry yields one pair per occurrence.
+
+    .PARAMETER PathA
+        First path collection. An empty collection and empty strings are accepted.
+
+    .PARAMETER PathB
+        Second path collection. An empty collection and empty strings are accepted.
+
+    .OUTPUTS
+        System.Object[]. One hashtable per overlapping pair with keys EntryA (from
+        PathA) and EntryB (from PathB); an empty array when nothing overlaps.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [AllowEmptyString()]
+        [string[]] $PathA,
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [AllowEmptyString()]
+        [string[]] $PathB
+    )
+
+    $recordA = @(ConvertTo-PathOverlapRecord -Entry $PathA)
+    $recordB = @(ConvertTo-PathOverlapRecord -Entry $PathB)
+    $countB = [long]$recordB.Count
+    $pairKey = [System.Collections.Generic.HashSet[long]]::new()
+    $hit = $null
+
+    # Concrete entries keyed verbatim (equality) and trimmed of trailing separators
+    # (containment); each key lists every index carrying it, one per occurrence.
+    $exactB, $trimmedB, $trimmedA = @(1..3 | ForEach-Object { [System.Collections.Generic.Dictionary[string, System.Collections.Generic.List[int]]]::new([StringComparer]::Ordinal) })
+    for ($j = 0; $j -lt $recordB.Count; $j++) {
+        if ($recordB[$j].IsGlob) { continue }
+        foreach ($target in @(@($exactB, $recordB[$j].Entry), @($trimmedB, $recordB[$j].Entry.TrimEnd('/')))) {
+            if (-not $target[0].ContainsKey($target[1])) { $target[0][$target[1]] = [System.Collections.Generic.List[int]]::new() }
+            $target[0][$target[1]].Add($j)
+        }
+    }
+
+    for ($i = 0; $i -lt $recordA.Count; $i++) {
+        $entry = $recordA[$i].Entry
+        if ($recordA[$i].IsGlob) {
+            # A PathA glob is decided against every PathB record.
+            for ($j = 0; $j -lt $recordB.Count; $j++) {
+                if (Test-PathOverlapRecordPair -Left $recordA[$i] -Right $recordB[$j]) { [void]$pairKey.Add($i * $countB + $j) }
+            }
+            continue
+        }
+        if (-not $trimmedA.ContainsKey($entry.TrimEnd('/'))) { $trimmedA[$entry.TrimEnd('/')] = [System.Collections.Generic.List[int]]::new() }
+        $trimmedA[$entry.TrimEnd('/')].Add($i)
+        # Equality, then containment at each separator (the PathB pass probes the reverse).
+        if ($exactB.TryGetValue($entry, [ref]$hit)) { foreach ($j in $hit) { [void]$pairKey.Add($i * $countB + $j) } }
+        for ($slash = $entry.IndexOf('/'); $slash -ge 0; $slash = $entry.IndexOf('/', $slash + 1)) {
+            if ($trimmedB.TryGetValue($entry.Substring(0, $slash), [ref]$hit)) { foreach ($j in $hit) { [void]$pairKey.Add($i * $countB + $j) } }
+        }
+    }
+
+    for ($j = 0; $j -lt $recordB.Count; $j++) {
+        $entry = $recordB[$j].Entry
+        if ($recordB[$j].IsGlob) {
+            # Against concrete PathA records only; glob pairs were decided above.
+            for ($i = 0; $i -lt $recordA.Count; $i++) {
+                if (-not $recordA[$i].IsGlob -and (Test-PathOverlapRecordPair -Left $recordA[$i] -Right $recordB[$j])) { [void]$pairKey.Add($i * $countB + $j) }
+            }
+            continue
+        }
+        for ($slash = $entry.IndexOf('/'); $slash -ge 0; $slash = $entry.IndexOf('/', $slash + 1)) {
+            if ($trimmedA.TryGetValue($entry.Substring(0, $slash), [ref]$hit)) { foreach ($i in $hit) { [void]$pairKey.Add($i * $countB + $j) } }
+        }
+    }
+
+    $sortedKey = [long[]]@($pairKey)
+    [System.Array]::Sort($sortedKey)
+    $pair = [System.Collections.Generic.List[hashtable]]::new()
+    foreach ($key in $sortedKey) {
+        $i = [int][System.Math]::Floor($key / $countB)
+        $pair.Add(@{ EntryA = $recordA[$i].Entry; EntryB = $recordB[[int]($key - $i * $countB)].Entry })
+    }
+
+    return @($pair.ToArray())
+}
+
 function Get-SmallestPathOverlap {
     <#
     .SYNOPSIS
@@ -222,22 +398,24 @@ function Get-SmallestPathOverlap {
         [string[]] $PathB
     )
 
-    $detail = [System.Collections.Generic.List[string]]::new()
-    foreach ($entryA in $PathA) {
-        foreach ($entryB in $PathB) {
-            if (-not (Test-EntryOverlap -EntryA $entryA -EntryB $entryB)) {
-                continue
-            }
-            $ordered = if ([string]::CompareOrdinal($entryA, $entryB) -le 0) {
-                @($entryA, $entryB)
-            } else {
-                @($entryB, $entryA)
-            }
-            $detail.Add($ordered -join $script:PairDetailSeparator)
+    # The overlapping pairs come from the shared enumeration, so the record-form
+    # decision exists once (issue #776). The minimum over the ordered details does
+    # not depend on the order in which the pairs are enumerated.
+    $smallest = $null
+    foreach ($pair in @(Get-OverlappingPathPair -PathA $PathA -PathB $PathB)) {
+        # Order the pair ordinally so the detail is identical in both argument
+        # orders, then keep it only when it is the new ordinal minimum.
+        $pairDetail = if ([string]::CompareOrdinal($pair['EntryA'], $pair['EntryB']) -le 0) {
+            $pair['EntryA'] + $script:PairDetailSeparator + $pair['EntryB']
+        } else {
+            $pair['EntryB'] + $script:PairDetailSeparator + $pair['EntryA']
+        }
+        if ($null -eq $smallest -or [string]::CompareOrdinal($pairDetail, $smallest) -lt 0) {
+            $smallest = $pairDetail
         }
     }
 
-    return (Get-OrdinalSmallestEntry -Entry $detail.ToArray())
+    return $smallest
 }
 
 function Get-SmallestCommonEntry {
@@ -287,4 +465,5 @@ Export-ModuleMember -Function `
     Test-MergeablePath, `
     Get-NonMergeablePathEntry, `
     Get-SmallestPathOverlap, `
-    Get-SmallestCommonEntry
+    Get-SmallestCommonEntry, `
+    Get-OverlappingPathPair

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadiusGlob.psm1

@@ -31,6 +31,9 @@
         newline in .NET.
       - Comparisons and ordering use [StringComparer]::Ordinal and
         [string]::CompareOrdinal so results do not vary with the current culture.
+      - Test-GlobMatch memoizes each translated pattern in a script-scoped,
+        ordinally keyed regex cache (issue #776). The translation is pure, so
+        the cache changes speed only; Python recompiles through re's own cache.
     CONVENTION: this module fails fast at module scope and imports its siblings with -ErrorAction Stop.
 #>
 
@@ -40,7 +43,12 @@ $ErrorActionPreference = 'Stop'
 # Wildcards that make a path entry a pattern rather than a file. The question
 # mark is included because the subsumption helper treats it as a pattern;
 # admitting it here keeps every comparison in the fail-closed direction.
-$script:GlobWildcard = @('*', '?')
+$script:GlobWildcardCharacter = [char[]]@('*', '?')
+
+# Compiled whole-string regex per glob pattern (issue #776). Keys compare
+# ordinally so patterns differing only by case stay distinct. The cache lives
+# per module instance and is bounded by the number of distinct patterns seen.
+$script:GlobRegexCache = [System.Collections.Generic.Dictionary[string, regex]]::new([StringComparer]::Ordinal)
 
 
 function Test-GlobEntry {
@@ -49,8 +57,8 @@ function Test-GlobEntry {
         Report whether a path entry is a wildcard pattern rather than a file.
 
     .DESCRIPTION
-        Port of is_glob_entry. Used both to classify radius path entries and, one
-        character at a time, by the literal-prefix helper.
+        Port of is_glob_entry. Used to classify radius path entries; a single
+        ordinal IndexOfAny scan over the wildcard set decides the answer.
 
     .PARAMETER Entry
         A paths entry from a radius or an extraction, or a single character.
@@ -66,13 +74,7 @@ function Test-GlobEntry {
         [string] $Entry
     )
 
-    foreach ($wildcard in $script:GlobWildcard) {
-        if ($Entry.IndexOf($wildcard, [System.StringComparison]::Ordinal) -ge 0) {
-            return $true
-        }
-    }
-
-    return $false
+    return $Entry.IndexOfAny($script:GlobWildcardCharacter) -ge 0
 }
 
 function Get-ConcreteEntry {
@@ -147,6 +149,23 @@ function ConvertTo-GlobRegexText {
     return $part.ToString()
 }
 
+# Return the cached anchored regex for a glob pattern, building it on a miss.
+# Declared as a simple function, without [CmdletBinding()], because it runs once
+# per Test-GlobMatch call and advanced-function parameter binding is the
+# per-call cost issue #776 removes from the pairwise overlap hot path.
+function Get-GlobRegex {
+    param([string] $Pattern)
+
+    $cached = $null
+    if ($script:GlobRegexCache.TryGetValue($Pattern, [ref]$cached)) {
+        return $cached
+    }
+
+    $compiled = [regex]::new('\A(?:' + (ConvertTo-GlobRegexText -Pattern $Pattern) + ')\z')
+    $script:GlobRegexCache[$Pattern] = $compiled
+    return $compiled
+}
+
 function Test-GlobMatch {
     <#
     .SYNOPSIS
@@ -176,8 +195,7 @@ function Test-GlobMatch {
         [string] $Candidate
     )
 
-    $regexText = '\A(?:' + (ConvertTo-GlobRegexText -Pattern $Pattern) + ')\z'
-    return [regex]::IsMatch($Candidate, $regexText)
+    return (Get-GlobRegex -Pattern $Pattern).IsMatch($Candidate)
 }
 
 function Test-PathSubsumed {
@@ -261,10 +279,9 @@ function Get-LiteralPrefix {
         [string] $Entry
     )
 
-    for ($index = 0; $index -lt $Entry.Length; $index++) {
-        if (Test-GlobEntry -Entry ([string]$Entry[$index])) {
-            return $Entry.Substring(0, $index)
-        }
+    $index = $Entry.IndexOfAny($script:GlobWildcardCharacter)
+    if ($index -ge 0) {
+        return $Entry.Substring(0, $index)
     }
 
     return $Entry
@@ -308,8 +325,12 @@ function Test-EntryOverlap {
         [string] $EntryB
     )
 
-    $aIsGlob = Test-GlobEntry -Entry $EntryA
-    $bIsGlob = Test-GlobEntry -Entry $EntryB
+    # One ordinal scan per entry yields both the glob flag and the literal prefix,
+    # so this hot path makes no advanced-function call for either (issue #776).
+    $indexA = $EntryA.IndexOfAny($script:GlobWildcardCharacter)
+    $indexB = $EntryB.IndexOfAny($script:GlobWildcardCharacter)
+    $aIsGlob = $indexA -ge 0
+    $bIsGlob = $indexB -ge 0
 
     if (-not $aIsGlob -and -not $bIsGlob) {
         # Anchoring each entry with a trailing separator before the prefix test is
@@ -326,23 +347,25 @@ function Test-EntryOverlap {
     # entry's directory prefix nest. The nest is tested in both directions because
     # the glob may be rooted above the directory (scripts/ above
     # scripts/dev_tools/) or below it, and either arrangement admits a common file.
+    # The two literal nest tests run before the pattern match: all three terms are
+    # pure, so the order of the OR changes cost only, never the verdict.
     if ($aIsGlob -and -not $bIsGlob) {
-        $prefixGlob = Get-LiteralPrefix -Entry $EntryA
+        $prefixGlob = $EntryA.Substring(0, $indexA)
         $directoryConcrete = $EntryB.TrimEnd('/') + '/'
-        return ((Test-GlobMatch -Pattern $EntryA -Candidate $EntryB) -or
-            $prefixGlob.StartsWith($directoryConcrete, [System.StringComparison]::Ordinal) -or
-            $directoryConcrete.StartsWith($prefixGlob, [System.StringComparison]::Ordinal))
+        return ($prefixGlob.StartsWith($directoryConcrete, [System.StringComparison]::Ordinal) -or
+            $directoryConcrete.StartsWith($prefixGlob, [System.StringComparison]::Ordinal) -or
+            (Test-GlobMatch -Pattern $EntryA -Candidate $EntryB))
     }
     if ($bIsGlob -and -not $aIsGlob) {
-        $prefixGlob = Get-LiteralPrefix -Entry $EntryB
+        $prefixGlob = $EntryB.Substring(0, $indexB)
         $directoryConcrete = $EntryA.TrimEnd('/') + '/'
-        return ((Test-GlobMatch -Pattern $EntryB -Candidate $EntryA) -or
-            $prefixGlob.StartsWith($directoryConcrete, [System.StringComparison]::Ordinal) -or
-            $directoryConcrete.StartsWith($prefixGlob, [System.StringComparison]::Ordinal))
+        return ($prefixGlob.StartsWith($directoryConcrete, [System.StringComparison]::Ordinal) -or
+            $directoryConcrete.StartsWith($prefixGlob, [System.StringComparison]::Ordinal) -or
+            (Test-GlobMatch -Pattern $EntryB -Candidate $EntryA))
     }
 
-    $prefixA = Get-LiteralPrefix -Entry $EntryA
-    $prefixB = Get-LiteralPrefix -Entry $EntryB
+    $prefixA = $EntryA.Substring(0, $indexA)
+    $prefixB = $EntryB.Substring(0, $indexB)
     return ($prefixA.StartsWith($prefixB, [System.StringComparison]::Ordinal) -or
         $prefixB.StartsWith($prefixA, [System.StringComparison]::Ordinal))
 }

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadiusScheduling.psm1

@@ -261,15 +261,12 @@ function Get-BlastRadiusPairCost {
     $pathsA = @(Get-NonMergeablePathEntry -Entry ([string[]]@($left['paths'])) -MergeablePath $mergeable)
     $pathsB = @(Get-NonMergeablePathEntry -Entry ([string[]]@($right['paths'])) -MergeablePath $mergeable)
 
-    # Enumerate the overlapping pairs with the relation's own primitive, so the
-    # cost covers exactly the pairs the relation could report.
+    # Enumerate the overlapping pairs with the relation's own indexed enumeration
+    # (the Test-EntryOverlap pairs, issue #776), so the cost covers exactly the
+    # pairs the relation could report.
     [long]$cost = 0
-    foreach ($entryA in $pathsA) {
-        foreach ($entryB in $pathsB) {
-            if (Test-EntryOverlap -EntryA $entryA -EntryB $entryB) {
-                $cost += Get-PathPairWeight -EntryA $entryA -EntryB $entryB -Tolerance $Tolerance
-            }
-        }
+    foreach ($pair in @(Get-OverlappingPathPair -PathA $pathsA -PathB $pathsB)) {
+        $cost += Get-PathPairWeight -EntryA $pair['EntryA'] -EntryB $pair['EntryB'] -Tolerance $Tolerance
     }
     $sharedModule = @(@($left['modules']) | Where-Object { @($right['modules']) -ccontains $_ })
     return $cost + ([long]$Tolerance['weights']['module'] * $sharedModule.Count)