bc-code-intelligence-mcp 1.5.9 → 1.6.0

package/embedded-knowledge/domains/sam-coder/generic-method-patterns-al.md

@@ -7,6 +7,16 @@ tags: ["generic-methods", "type-safety", "code-reuse", "al-generics"]
 prerequisites: ["al-basics", "interface-implementation", "advanced-al-features"]
 samples: "samples/generic-method-patterns.md"
 related_topics: ["type-safe-operations-al", "template-method-pattern-al"]
+
+relevance_signals:
+  constructs: ["interface", "Variant", "RecordRef", "FieldRef"]
+  keywords: ["generic methods", "type-safe", "code reuse", "type parameter", "constraint", "type inference"]
+  anti_pattern_indicators: ["over-generalization", "constraint misuse", "performance degradation", "complex type hierarchies"]
+  positive_pattern_indicators: ["type-safe algorithms", "generic factory", "interface-based generics", "meaningful type parameters"]
+
+applicable_object_types: ["codeunit", "interface"]
+
+relevance_threshold: 0.5
 ---
 
 # Generic Method Patterns in AL

package/embedded-knowledge/domains/sam-coder/manual-binding-conditional-subscribers.md

@@ -6,6 +6,16 @@ bc_versions: "16+"
 tags: ["events", "binding", "conditional", "runtime"]
 prerequisites: ["event-subscriber-basics", "binding-patterns"]
 samples: "samples/manual-binding.md"
+
+relevance_signals:
+  constructs: ["EventSubscriber", "BindSubscription", "UnbindSubscription"]
+  keywords: ["manual binding", "conditional subscriber", "runtime binding", "event registration", "feature toggle", "multi-tenant"]
+  anti_pattern_indicators: ["failed deregistration", "registration failures", "inconsistent binding state", "missing lifecycle management"]
+  positive_pattern_indicators: ["conditional event processing", "dynamic binding", "feature-flag-controlled", "explicit lifecycle management"]
+
+applicable_object_types: ["codeunit"]
+
+relevance_threshold: 0.6
 ---
 # Manual Binding for Conditional Event Subscribers
 

package/embedded-knowledge/domains/sam-coder/nested-compound-best-practices.md

@@ -6,6 +6,16 @@ bc_versions: "14+"
 tags: ["nested-statements", "code-organization", "readability", "complexity-management"]
 prerequisites: ["compound-statement-readability", "al-control-flow"]
 samples: "samples/nested-compound-best-practices.md"
+
+relevance_signals:
+  constructs: ["begin", "end", "if", "then", "else", "while", "repeat"]
+  keywords: ["nested statements", "compound blocks", "nesting depth", "code organization", "complexity management", "readability"]
+  anti_pattern_indicators: ["deep nesting", "excessive complexity", "more than three levels", "cognitive overload"]
+  positive_pattern_indicators: ["depth limitation", "logical organization", "strategic extraction", "consistent formatting"]
+
+applicable_object_types: ["codeunit", "page", "table", "report"]
+
+relevance_threshold: 0.5
 ---
 # AL Nested Compound Statement Best Practices
 

package/embedded-knowledge/domains/sam-coder/single-to-compound-conversion.md

@@ -1,4 +1,4 @@
----
+---
 title: "Converting AL Single Statements to Compound Blocks"
 domain: "sam-coder"
 difficulty: "beginner"
@@ -6,7 +6,17 @@ bc_versions: "14+"
 tags: ["refactoring", "compound-statements", "code-conversion", "development-workflow"]
 prerequisites: ["al-syntax-basics", "compound-statement-readability"]
 samples: "samples/single-to-compound-conversion.md"
----
+
+relevance_signals:
+  constructs: ["begin", "end", "if", "then", "else", "while", "repeat"]
+  keywords: ["refactoring", "compound statements", "code conversion", "begin-end blocks", "single statement", "future-proofing"]
+  anti_pattern_indicators: ["single statement without begin-end", "if-then without block", "inconsistent patterns"]
+  positive_pattern_indicators: ["compound block structure", "explicit begin-end", "consistent refactoring", "safe transformation"]
+
+applicable_object_types: ["codeunit", "page", "table", "report"]
+
+relevance_threshold: 0.4
+---
 # Converting AL Single Statements to Compound Blocks
 
 ## Overview

package/embedded-knowledge/domains/sam-coder/template-method-pattern-al.md

@@ -7,6 +7,16 @@ tags: ["template-method", "behavioral-patterns", "algorithm-structure", "inherit
 prerequisites: ["object-orientation-al", "inheritance-patterns", "virtual-methods"]
 samples: "samples/template-method-pattern.md"
 related_topics: ["business-process-template-patterns", "type-safe-operations-al"]
+
+relevance_signals:
+  constructs: ["interface", "implements", "procedure"]
+  keywords: ["template method", "algorithm skeleton", "extension points", "inheritance", "virtual method", "behavioral pattern"]
+  anti_pattern_indicators: ["template complexity", "inflexible design", "too many extension points"]
+  positive_pattern_indicators: ["stable algorithm framework", "customizable steps", "invariant operations", "clear extension points"]
+
+applicable_object_types: ["codeunit", "interface"]
+
+relevance_threshold: 0.5
 ---
 
 # Template Method Pattern in AL

package/embedded-knowledge/domains/sam-coder/testfield-patterns.md

@@ -1,4 +1,4 @@
----
+---
 title: "TestField Best Practices and Patterns"
 domain: "sam-coder"
 difficulty: "intermediate"
@@ -6,7 +6,17 @@ bc_versions: "14+"
 tags: ["best-practices", "validation", "code-quality", "maintainability"]
 prerequisites: ["testfield-basic-syntax", "testfield-error-handling"]
 samples: "samples/testfield-patterns.md"
----
+
+relevance_signals:
+  constructs: ["TestField", "FieldError", "Error"]
+  keywords: ["TestField", "validation", "mandatory field", "data integrity", "field validation", "status-driven validation"]
+  anti_pattern_indicators: ["over-validation", "mixed concerns", "performance-blind validation", "context-blind validation"]
+  positive_pattern_indicators: ["fail fast", "logical validation grouping", "context-appropriate validation", "progressive validation"]
+
+applicable_object_types: ["codeunit", "page", "table"]
+
+relevance_threshold: 0.6
+---
 # TestField Best Practices and Patterns
 
 ## Overview

package/embedded-knowledge/domains/sam-coder/type-safe-operations-al.md

@@ -7,6 +7,16 @@ tags: ["type-safety", "compile-time-validation", "strong-typing", "error-prevent
 prerequisites: ["al-data-types", "variable-declaration", "procedure-design"]
 samples: "samples/type-safe-operations.md"
 related_topics: ["generic-method-patterns-al", "template-method-pattern-al"]
+
+relevance_signals:
+  constructs: ["Enum", "interface", "Option", "Record"]
+  keywords: ["type safety", "compile-time validation", "strong typing", "type-safe", "explicit type declarations", "enumeration"]
+  anti_pattern_indicators: ["over-engineering types", "implicit conversion", "type mismatch", "weak typing"]
+  positive_pattern_indicators: ["strongly-typed identifiers", "type-safe enumerations", "explicit type declarations", "compile-time checking"]
+
+applicable_object_types: ["codeunit", "table", "enum", "interface"]
+
+relevance_threshold: 0.5
 ---
 
 # Type-Safe Operations in AL

package/embedded-knowledge/domains/sam-coder/vs-code-al-keyboard-shortcuts.md

@@ -5,6 +5,16 @@ difficulty: "beginner"
 bc_versions: "14+"
 tags: ["vs-code", "productivity", "shortcuts", "al-extension", "navigation"]
 prerequisites: ["vs-code-setup", "al-extension-basics"]
+
+relevance_signals:
+  constructs: []
+  keywords: ["keyboard shortcuts", "VS Code", "productivity", "IntelliSense", "debugging", "F12", "Ctrl+Space", "navigation"]
+  anti_pattern_indicators: []
+  positive_pattern_indicators: ["muscle memory", "coding flow", "efficient navigation", "shortcut mastery"]
+
+applicable_object_types: ["codeunit", "page", "table", "report", "query", "xmlport", "enum", "interface"]
+
+relevance_threshold: 0.3
 ---
 
 # VS Code AL Extension Keyboard Shortcuts

package/embedded-knowledge/domains/seth-security/al-temporary-table-safety.md

@@ -14,6 +14,16 @@ implementation_steps: ["validate-data-scope", "implement-secure-cleanup", "test-
 validation_criteria: ["secure-data-handling", "proper-memory-cleanup"]
 technical_areas: ["al-code", "data-management"]
 samples: "samples/al-temporary-table-safety.md"
+
+relevance_signals:
+  constructs: ["IsTemporary", "DeleteAll", "ModifyAll", "Insert", "Delete", "Modify", "Reset", "Copy"]
+  keywords: ["temporary table", "in-memory", "data leakage", "memory management", "session isolation", "security context", "data protection", "cleanup", "scope management"]
+  anti_pattern_indicators: ["persistent temporary data", "permission bypass", "cross-session leakage", "uncontrolled scope", "failing to clear"]
+  positive_pattern_indicators: ["secure initialization", "permission validation", "explicit clearing", "try-finally", "error handling cleanup", "minimal data", "data filtering"]
+
+applicable_object_types: ["codeunit", "table", "page", "report"]
+
+relevance_threshold: 0.7
 ---
 
 # AL Temporary Table Safety

package/embedded-knowledge/domains/seth-security/api-permission-model.md

@@ -1,11 +1,21 @@
----
+---
 title: "API Page Permission Model"
 domain: "seth-security"
 difficulty: "intermediate"
 bc_versions: "14+"
 tags: ["api-permissions", "access-control", "security"]
 samples: "samples/api-permission-model.md"
----
+
+relevance_signals:
+  constructs: ["APIPublisher", "APIGroup", "APIVersion", "ODataKeyFields", "EntityName", "EntitySetName", "Permissions", "TableData"]
+  keywords: ["API page", "OData", "permission model", "access control", "service account", "authentication", "authorization", "field-level security", "tenant isolation", "compliance", "audit"]
+  anti_pattern_indicators: ["missing permissions", "no authentication", "unprotected API", "exposed sensitive fields", "bypass security"]
+  positive_pattern_indicators: ["least privilege", "defense in depth", "permission sets", "field permissions", "audit trail", "service account", "OAuth"]
+
+applicable_object_types: ["page", "permissionset", "codeunit"]
+
+relevance_threshold: 0.7
+---
 # API Page Permission Model
 
 ## Overview

package/embedded-knowledge/domains/seth-security/istemporary-safeguard-pattern.md

@@ -1,11 +1,21 @@
----
+---
 title: "IsTemporary Table Safeguard Pattern for Data Protection"
 domain: "seth-security"
 difficulty: "intermediate"
 bc_versions: "14+"
 tags: ["data-protection", "temporary-tables", "safeguards", "data-integrity", "error-prevention"]
 prerequisites: ["al-tables", "data-access-patterns"]
----
+
+relevance_signals:
+  constructs: ["IsTemporary", "DeleteAll", "ModifyAll", "Insert", "Delete", "Modify", "Error"]
+  keywords: ["temporary table", "safeguard", "data protection", "bulk operation", "validation gate", "error prevention", "permanent table", "database safety"]
+  anti_pattern_indicators: ["skipping validation", "silent failure", "late validation", "generic error handling", "bypassing IsTemporary check"]
+  positive_pattern_indicators: ["early validation", "clear error messages", "conditional operations", "defensive programming", "precondition check"]
+
+applicable_object_types: ["codeunit", "table", "page", "report"]
+
+relevance_threshold: 0.7
+---
 # IsTemporary Table Safeguard Pattern for Data Protection
 
 ## Overview

package/embedded-knowledge/domains/shared/al-file-naming-conventions.md

@@ -14,6 +14,16 @@ implementation_steps: ["identify-object-name", "apply-object-type-suffix", "vali
 validation_criteria: ["consistent-naming-application", "standards-compliance"]
 technical_areas: ["al-code", "file-organization"]
 related_topics: ["al-variable-naming-conventions", "al-standard-abbreviations"]
+
+relevance_signals:
+  constructs: []
+  keywords: ["file naming", "naming convention", "TableExt", "PageExt", "Codeunit", "Table", "Page", "Report", "Query", "XMLport", "Enum", "Interface", "PermissionSet", "Pascal Case"]
+  anti_pattern_indicators: ["Tab-Ext", "Pag-Ext", "Cod50100", "object ID in filename", "underscore notation", "inconsistent casing"]
+  positive_pattern_indicators: ["ObjectName.ObjectType.al", "Pascal Case", "descriptive", "consistent prefixes", "logical grouping"]
+
+applicable_object_types: ["codeunit", "table", "tableextension", "page", "pageextension", "report", "reportextension", "query", "xmlport", "enum", "enumextension", "interface", "permissionset", "permissionsetextension", "profile", "controladdin"]
+
+relevance_threshold: 0.5
 ---
 
 # AL File Naming Conventions

package/embedded-knowledge/domains/taylor-docs/al-xml-documentation-structure.md

@@ -5,6 +5,16 @@ difficulty: "intermediate"
 bc_versions: "18+"
 tags: ["xml-documentation", "intellisense", "api-documentation", "object-documentation"]
 prerequisites: ["al-objects", "xml-basics"]
+
+relevance_signals:
+  constructs: ["summary", "param", "returns", "example", "remarks"]
+  keywords: ["XML documentation", "IntelliSense", "API documentation", "triple-slash", "documentation comment", "object documentation", "procedure documentation"]
+  anti_pattern_indicators: ["minimal documentation", "copy-paste descriptions", "outdated information", "excessive detail", "missing parameter info"]
+  positive_pattern_indicators: ["complete coverage", "clear language", "accurate information", "meaningful examples", "version control", "review process"]
+
+applicable_object_types: ["codeunit", "table", "page", "report", "query", "xmlport", "enum", "interface"]
+
+relevance_threshold: 0.4
 ---
 # AL XML Documentation Comment Structure for Objects
 

package/embedded-knowledge/domains/uma-ux/bc-action-shortcuts-syntax.md

@@ -1,11 +1,21 @@
----
+---
 title: "Business Central Action Shortcut Key Syntax and Implementation"
 domain: "uma-ux"
 difficulty: "intermediate"
 bc_versions: "14+"
 tags: ["shortcuts", "actions", "user-interface", "accessibility", "keyboard-navigation"]
 prerequisites: ["bc-actions", "page-design"]
----
+
+relevance_signals:
+  constructs: ["ShortcutKey", "ApplicationArea", "Promoted", "PromotedCategory", "ToolTip", "Caption"]
+  keywords: ["shortcut key", "keyboard shortcut", "action", "accessibility", "keyboard navigation", "Ctrl", "Alt", "Shift", "F-key", "modifier key"]
+  anti_pattern_indicators: ["conflicting assignments", "obscure combinations", "inconsistent patterns", "missing accessibility", "undocumented shortcuts"]
+  positive_pattern_indicators: ["intuitive mapping", "standard conventions", "conflict avoidance", "accessibility compliance", "tooltip inclusion"]
+
+applicable_object_types: ["page", "pageextension"]
+
+relevance_threshold: 0.4
+---
 # Business Central Action Shortcut Key Syntax and Implementation
 
 ## Overview

package/embedded-knowledge/domains/uma-ux/shortcut-key-user-experience-design.md

@@ -1,11 +1,21 @@
----
+---
 title: "Shortcut Key User Experience Design in Business Central Applications"
 domain: "uma-ux"
 difficulty: "intermediate"
 bc_versions: "14+"
 tags: ["user-experience", "shortcuts", "workflow-optimization", "productivity", "interface-design"]
 prerequisites: ["user-interface-design", "bc-actions"]
----
+
+relevance_signals:
+  constructs: ["ShortcutKey", "ToolTip", "Caption", "ApplicationArea", "Promoted"]
+  keywords: ["user experience", "shortcut", "workflow optimization", "productivity", "keyboard navigation", "progressive disclosure", "cognitive load", "discoverability", "power user"]
+  anti_pattern_indicators: ["overcomplex combinations", "hidden functionality", "inconsistent behavior", "conflict creation", "no visual feedback"]
+  positive_pattern_indicators: ["workflow analysis", "frequency-based prioritization", "memorable patterns", "visual cues", "help integration", "progressive revelation"]
+
+applicable_object_types: ["page", "pageextension"]
+
+relevance_threshold: 0.4
+---
 # Shortcut Key User Experience Design in Business Central Applications
 
 ## Overview

package/embedded-knowledge/scripts/frontmatter_validator.ps1

@@ -0,0 +1,330 @@
+# frontmatter_validator.ps1
+# Validates knowledge file frontmatter against v2 schema requirements
+
+param(
+    [string]$Path = "..\domains",
+    [switch]$ExcludeSamples = $true,
+    [switch]$V2Only = $false  # Only check v2 fields, skip files without them
+)
+
+$script:ErrorCount = 0
+$script:WarningCount = 0
+$script:ValidCount = 0
+$script:SkippedCount = 0
+
+function Write-ValidationError {
+    param([string]$File, [string]$Message)
+    Write-Host "  ERROR: $Message" -ForegroundColor Red
+    $script:ErrorCount++
+}
+
+function Write-ValidationWarning {
+    param([string]$File, [string]$Message)
+    Write-Host "  WARN:  $Message" -ForegroundColor Yellow
+    $script:WarningCount++
+}
+
+function Test-IsArray {
+    param($Value)
+    return $Value -is [System.Collections.IEnumerable] -and $Value -isnot [string]
+}
+
+function Test-IsArrayOfStrings {
+    param($Value)
+    if (-not (Test-IsArray $Value)) { return $false }
+    foreach ($item in $Value) {
+        if ($item -isnot [string]) { return $false }
+    }
+    return $true
+}
+
+function Parse-YamlFrontmatter {
+    param([string]$Content)
+
+    # Extract frontmatter between --- markers
+    if ($Content -notmatch '^---\s*\r?\n([\s\S]*?)\r?\n---') {
+        return $null
+    }
+
+    $yamlContent = $Matches[1]
+    $result = @{}
+    $currentKey = $null
+    $currentIndent = 0
+    $inArray = $false
+    $arrayKey = $null
+    $nestedObject = $null
+    $nestedKey = $null
+
+    foreach ($line in $yamlContent -split '\r?\n') {
+        # Skip comments only - blank lines reset nested context but don't skip
+        if ($line -match '^\s*#') { continue }
+
+        # Blank lines reset nested object context (back to top level)
+        if ($line -match '^\s*$') {
+            $nestedObject = $null
+            $nestedKey = $null
+            $currentKey = $null
+            $arrayKey = $null
+            continue
+        }
+
+        # Detect indent level
+        $indent = 0
+        if ($line -match '^(\s*)') {
+            $indent = $Matches[1].Length
+        }
+
+        $trimmedLine = $line.Trim()
+
+        # Array item
+        if ($trimmedLine -match '^-\s*(.*)$') {
+            $value = $Matches[1].Trim()
+            # Remove quotes if present
+            if ($value -match '^[''"](.*)[''"]\s*$') {
+                $value = $Matches[1]
+            }
+            if ($nestedKey -and $nestedObject) {
+                if (-not $nestedObject[$nestedKey]) {
+                    $nestedObject[$nestedKey] = @()
+                }
+                $nestedObject[$nestedKey] += $value
+            } elseif ($arrayKey) {
+                if (-not $result[$arrayKey]) {
+                    $result[$arrayKey] = @()
+                }
+                $result[$arrayKey] += $value
+            }
+            continue
+        }
+
+        # Key-value pair
+        if ($trimmedLine -match '^([^:]+):\s*(.*)$') {
+            $key = $Matches[1].Trim()
+            $value = $Matches[2].Trim()
+
+            # Remove quotes if present
+            if ($value -match '^[''"](.*)[''"]\s*$') {
+                $value = $Matches[1]
+            }
+
+            # Check if this is a nested object key (indented under another key)
+            if ($indent -gt 0 -and $currentKey) {
+                if (-not $result[$currentKey]) {
+                    $result[$currentKey] = @{}
+                }
+                $nestedObject = $result[$currentKey]
+                $nestedKey = $key
+
+                if ($value -eq '' -or $value -match '^\[') {
+                    # Empty value or inline array - prepare for array items
+                    if ($value -match '^\[(.*)\]$') {
+                        # Inline array
+                        $items = $Matches[1] -split ',\s*' | ForEach-Object {
+                            $_.Trim().Trim('"').Trim("'")
+                        } | Where-Object { $_ -ne '' }
+                        $nestedObject[$key] = @($items)
+                    } else {
+                        $nestedObject[$key] = @()
+                    }
+                } else {
+                    $nestedObject[$key] = $value
+                }
+            } else {
+                # Top-level key
+                $currentKey = $key
+                $nestedObject = $null
+                $nestedKey = $null
+
+                if ($value -eq '' -or $value -match '^\[') {
+                    # Empty value means object or array follows, or inline array
+                    if ($value -match '^\[(.*)\]$') {
+                        # Inline array
+                        $items = $Matches[1] -split ',\s*' | ForEach-Object {
+                            $_.Trim().Trim('"').Trim("'")
+                        } | Where-Object { $_ -ne '' }
+                        $result[$key] = @($items)
+                    } else {
+                        $arrayKey = $key
+                    }
+                } else {
+                    $result[$key] = $value
+                    $arrayKey = $null
+                }
+            }
+        }
+    }
+
+    return $result
+}
+
+function Validate-Frontmatter {
+    param(
+        [string]$FilePath,
+        [hashtable]$Frontmatter
+    )
+
+    $hasV2Fields = $Frontmatter.ContainsKey('relevance_signals') -or
+                   $Frontmatter.ContainsKey('applicable_object_types') -or
+                   $Frontmatter.ContainsKey('relevance_threshold')
+
+    if ($V2Only -and -not $hasV2Fields) {
+        $script:SkippedCount++
+        return $true
+    }
+
+    $isValid = $true
+    $fileName = Split-Path $FilePath -Leaf
+
+    Write-Host "`nValidating: $fileName" -ForegroundColor Cyan
+
+    # Check relevance_signals structure
+    if ($Frontmatter.ContainsKey('relevance_signals')) {
+        $rs = $Frontmatter['relevance_signals']
+
+        if ($rs -isnot [hashtable]) {
+            Write-ValidationError -File $FilePath -Message "relevance_signals must be an object"
+            $isValid = $false
+        } else {
+            # Check each sub-field
+            $arrayFields = @('constructs', 'keywords', 'anti_pattern_indicators', 'positive_pattern_indicators')
+            foreach ($field in $arrayFields) {
+                if ($rs.ContainsKey($field)) {
+                    $value = $rs[$field]
+                    if (-not (Test-IsArray $value)) {
+                        Write-ValidationError -File $FilePath -Message "relevance_signals.$field must be an array"
+                        $isValid = $false
+                    } elseif ($value.Count -gt 0 -and -not (Test-IsArrayOfStrings $value)) {
+                        Write-ValidationError -File $FilePath -Message "relevance_signals.$field must contain only strings"
+                        $isValid = $false
+                    }
+                }
+            }
+
+            # Warn if no signals defined
+            $hasAnySignals = $false
+            foreach ($field in $arrayFields) {
+                if ($rs.ContainsKey($field) -and $rs[$field].Count -gt 0) {
+                    $hasAnySignals = $true
+                    break
+                }
+            }
+            if (-not $hasAnySignals) {
+                Write-ValidationWarning -File $FilePath -Message "relevance_signals defined but no signals specified"
+            }
+        }
+    }
+
+    # Check applicable_object_types
+    if ($Frontmatter.ContainsKey('applicable_object_types')) {
+        $aot = $Frontmatter['applicable_object_types']
+        if (-not (Test-IsArray $aot)) {
+            Write-ValidationError -File $FilePath -Message "applicable_object_types must be an array"
+            $isValid = $false
+        } elseif ($aot.Count -gt 0 -and -not (Test-IsArrayOfStrings $aot)) {
+            Write-ValidationError -File $FilePath -Message "applicable_object_types must contain only strings"
+            $isValid = $false
+        }
+    }
+
+    # Check relevance_threshold
+    if ($Frontmatter.ContainsKey('relevance_threshold')) {
+        $rt = $Frontmatter['relevance_threshold']
+        $rtNum = 0
+        # Use InvariantCulture to handle decimal point regardless of system locale
+        if (-not [double]::TryParse($rt, [System.Globalization.NumberStyles]::Float, [System.Globalization.CultureInfo]::InvariantCulture, [ref]$rtNum)) {
+            Write-ValidationError -File $FilePath -Message "relevance_threshold must be a number"
+            $isValid = $false
+        } elseif ($rtNum -lt 0.0 -or $rtNum -gt 1.0) {
+            Write-ValidationError -File $FilePath -Message "relevance_threshold must be between 0.0 and 1.0 (got $rtNum)"
+            $isValid = $false
+        }
+    }
+
+    if ($isValid) {
+        if ($hasV2Fields) {
+            Write-Host "  OK (v2 fields valid)" -ForegroundColor Green
+        } else {
+            Write-Host "  OK (no v2 fields)" -ForegroundColor Gray
+        }
+        $script:ValidCount++
+    }
+
+    return $isValid
+}
+
+# Main execution
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$searchPath = Join-Path $scriptDir $Path
+
+if (-not (Test-Path $searchPath)) {
+    # Try relative to current directory
+    $searchPath = $Path
+}
+
+if (-not (Test-Path $searchPath)) {
+    Write-Host "Error: Path not found: $searchPath" -ForegroundColor Red
+    exit 1
+}
+
+Write-Host "=" * 60 -ForegroundColor White
+Write-Host "Frontmatter Validator - Knowledge Pattern V2" -ForegroundColor White
+Write-Host "=" * 60 -ForegroundColor White
+Write-Host "Scanning: $searchPath"
+Write-Host "Exclude samples: $ExcludeSamples"
+Write-Host "V2 fields only: $V2Only"
+Write-Host ""
+
+# Find all markdown files
+$files = Get-ChildItem -Path $searchPath -Filter "*.md" -Recurse
+
+if ($ExcludeSamples) {
+    $files = $files | Where-Object { $_.DirectoryName -notmatch '\\samples$' }
+}
+
+Write-Host "Found $($files.Count) files to validate`n"
+
+foreach ($file in $files) {
+    $content = Get-Content -Path $file.FullName -Raw -ErrorAction SilentlyContinue
+
+    if (-not $content) {
+        Write-Host "`nValidating: $($file.Name)" -ForegroundColor Cyan
+        Write-ValidationError -File $file.FullName -Message "Could not read file"
+        continue
+    }
+
+    # Check for frontmatter
+    if ($content -notmatch '^---') {
+        Write-Host "`nValidating: $($file.Name)" -ForegroundColor Cyan
+        Write-ValidationWarning -File $file.FullName -Message "No YAML frontmatter found"
+        $script:SkippedCount++
+        continue
+    }
+
+    $frontmatter = Parse-YamlFrontmatter -Content $content
+
+    if (-not $frontmatter) {
+        Write-Host "`nValidating: $($file.Name)" -ForegroundColor Cyan
+        Write-ValidationError -File $file.FullName -Message "Failed to parse YAML frontmatter"
+        continue
+    }
+
+    Validate-Frontmatter -FilePath $file.FullName -Frontmatter $frontmatter | Out-Null
+}
+
+# Summary
+Write-Host "`n" + ("=" * 60) -ForegroundColor White
+Write-Host "VALIDATION SUMMARY" -ForegroundColor White
+Write-Host "=" * 60 -ForegroundColor White
+Write-Host "Valid:    $script:ValidCount" -ForegroundColor Green
+Write-Host "Warnings: $script:WarningCount" -ForegroundColor Yellow
+Write-Host "Errors:   $script:ErrorCount" -ForegroundColor Red
+Write-Host "Skipped:  $script:SkippedCount" -ForegroundColor Gray
+Write-Host ""
+
+if ($script:ErrorCount -gt 0) {
+    Write-Host "VALIDATION FAILED" -ForegroundColor Red
+    exit 1
+} else {
+    Write-Host "VALIDATION PASSED" -ForegroundColor Green
+    exit 0
+}