@jwikman/bc-code-intelligence-mcp 1.5.7-dev.1

package/embedded-knowledge/methodologies/phases/verification.md

@@ -0,0 +1,146 @@
+# Verification Phase - Coverage Validation & Gap Resolution
+
+## Overview
+**Objective**: Ensure systematic completeness by validating that all planned analysis was completed and no critical optimizations were missed.
+
+**Key Principle**: No critical performance improvements should fall through coverage gaps. This phase serves as the final safety net to catch any missed files or patterns.
+
+## 🚨 MANDATORY PHASE - CANNOT BE SKIPPED
+**CRITICAL ENFORCEMENT**: This phase is REQUIRED for all optimization sessions. NO SESSION can be marked complete without successful verification phase completion.
+
+### Verification Phase Triggers Automatically When:
+- Performance phase claims completion
+- Optimization log contains completion markers
+- Session attempts to conclude without verification
+
+### Verification Phase BLOCKS Session Completion Until:
+- ✅ ALL files in scope verified as analyzed  
+- ✅ ALL claimed optimizations validated against actual files
+- ✅ ALL coverage gaps identified and resolved
+- ✅ NO phantom optimizations in documentation
+
+---
+
+## Phase Execution Process
+
+### Step 1: Coverage Checklist Validation
+**CRITICAL**: Cross-reference planned vs actual analysis coverage to identify gaps.
+
+#### 📋 File Coverage Validation
+- [ ] **Review File Inventory Checklist**
+  - [ ] Generate ACTUAL project file list using `find` or `glob` commands
+  - [ ] Compare ACTUAL files against optimization log entries
+  - [ ] Identify any files marked for analysis but not appearing in results
+  - [ ] **Red Flag**: Missing files from critical business domains (Analytics, Finance, Data Processing)
+
+#### 🔒 MANDATORY FILE VALIDATION GATES
+**CRITICAL**: These checks CANNOT be bypassed.
+
+- [ ] **Gate 1: Phantom File Detection**
+  - [ ] Cross-reference optimization log claims against actual project files
+  - [ ] **BLOCKING CONDITION**: Any claimed optimizations for non-existent files = INVALID SESSION
+  
+- [ ] **Gate 2: Missing File Detection**  
+  - [ ] Generate complete project file inventory using automated tools
+  - [ ] **BLOCKING CONDITION**: ANY files in scope missing from optimization log = INCOMPLETE SESSION
+  
+- [ ] **Gate 3: Coverage Accuracy Validation**
+  - [ ] Verify optimization claims match actual file contents
+  - [ ] **BLOCKING CONDITION**: False optimization claims = VERIFICATION RESTART REQUIRED
+
+#### 🔍 Pattern Coverage Validation  
+- [ ] **Review Pattern Detection Checklist**
+  - [ ] Verify each planned pattern was checked for each analyzed file
+  - [ ] Identify incomplete pattern coverage across file set
+  - [ ] **Red Flag**: Core patterns (Manual Summation, N+1 Queries) not checked consistently
+
+#### 📊 Coverage Reporting
+- [ ] **Generate Coverage Report**:
+  ```
+  PLANNED: 23 files across 4 modules for 17 patterns
+  ACTUAL: 22 files analyzed, 396 pattern checks completed
+  GAPS: 1 file missing (T4_BusinessIntelligence.Codeunit.al)
+  ```
+
+### Step 2: Gap Analysis & Risk Assessment
+**CRITICAL**: Assess impact of any identified coverage gaps.
+
+#### 🚨 Missing File Analysis
+For each identified missing file:
+- [ ] **Determine Business Criticality**
+  - High Risk: Analytics, Finance, Core Data Processing
+  - Medium Risk: Reporting, User Interface, Utilities  
+  - Low Risk: Configuration, Setup, Administrative functions
+
+- [ ] **Quick Pattern Scan** (for High/Medium risk files)
+  - [ ] Scan for manual summation loops (`repeat...until` with `+=`)
+  - [ ] Check for missing SetLoadFields optimizations
+  - [ ] Identify N+1 query anti-patterns (nested record loops)
+  - [ ] Look for FlowField vs CalcSums optimization opportunities
+
+#### ⚠️ Risk Classification
+- [ ] **CRITICAL**: High-risk files with confirmed performance anti-patterns
+- [ ] **MODERATE**: Medium-risk files with potential optimizations  
+- [ ] **MINOR**: Low-risk files or optimization patterns with minimal impact
+
+### Step 3: Automated Gap Resolution
+**CRITICAL**: Apply immediate fixes for critical gaps to prevent performance regressions.
+
+#### 🔥 Critical Gap Resolution
+For files classified as CRITICAL:
+- [ ] **Apply Standard Optimization Patterns**
+  - [ ] Replace manual summation with CalcSums operations
+  - [ ] Add SetLoadFields for selective field loading
+  - [ ] Eliminate N+1 query patterns with proper aggregation
+  - [ ] Apply database-first performance hierarchy principles
+
+- [ ] **Update Documentation**
+  - [ ] Add "VERIFICATION_PHASE" entries to optimization log
+  - [ ] Document pattern fixes and expected performance impact
+  - [ ] Update overall performance predictions
+
+#### 📋 Moderate Gap Documentation
+For files classified as MODERATE:
+- [ ] **Document for Future Analysis**
+  - [ ] Add to "Future Optimization Opportunities" section
+  - [ ] Note potential improvement areas for subsequent sessions
+  - [ ] Estimate impact and implementation effort
+
+### Step 4: Final Validation
+**CRITICAL**: Confirm systematic completeness before concluding optimization session.
+
+#### ✅ Completeness Checklist
+- [ ] **Coverage Validation Complete**: All planned files verified
+- [ ] **Critical Gaps Resolved**: High-risk missed optimizations applied
+- [ ] **Documentation Updated**: Optimization log reflects all changes
+- [ ] **Performance Predictions Revised**: Impact estimates include verification fixes
+
+#### 📊 Final Coverage Report
+- [ ] **Generate Final Summary**:
+  ```
+  VERIFICATION PHASE RESULTS:
+  - Files Analyzed: 23/23 (100% coverage achieved)
+  - Critical Gaps Found: 1 (T4_BusinessIntelligence.Codeunit.al)
+  - Critical Gaps Resolved: 1 (Manual summation → CalcSums conversion)
+  - Additional Optimizations Applied: 3 procedures optimized
+  - Updated Performance Prediction: +15% improvement from gap resolution
+  ```
+
+---
+
+## Success Criteria
+✅ **Complete Coverage Achieved**: All files in scope verified as analyzed  
+✅ **Critical Gaps Resolved**: No high-risk performance anti-patterns remaining
+✅ **Documentation Complete**: All optimization work properly documented
+✅ **Risk Assessment**: Any remaining gaps classified and documented for future work
+
+## Quality Validation
+- **Coverage Completeness**: Did you verify every file in the analysis scope?
+- **Gap Resolution**: Were critical missed optimizations properly addressed?
+- **Documentation Accuracy**: Does the optimization log reflect all work completed?
+- **Risk Management**: Are any remaining gaps properly classified and documented?
+
+---
+
+## Next Phase
+Upon completion, the optimization session is ready for **Testing & Validation Phase** with confidence that all critical performance improvements have been systematically applied.

package/embedded-knowledge/methodologies/workflow-enforcement.md

@@ -0,0 +1,142 @@
+# Methodology Workflow Enforcement - MANDATORY PHASE PROGRESSION
+
+## 🔒 CRITICAL ENFORCEMENT RULES
+
+**NO EXCEPTIONS**: These rules CANNOT be bypassed. Any violation INVALIDATES the entire optimization session.
+
+---
+
+## Phase Progression Rules
+
+### Rule 1: Sequential Phase Execution
+**MANDATORY ORDER**: Analysis → Performance → Verification
+- ❌ **FORBIDDEN**: Skipping any phase
+- ❌ **FORBIDDEN**: Reverse phase order  
+- ❌ **FORBIDDEN**: Parallel phase execution
+
+### Rule 2: Phase Completion Gates
+**BLOCKING CONDITIONS**: Each phase has mandatory gates that MUST pass before progression.
+
+#### Analysis Phase Gates
+- [ ] **Gate A1**: Complete file inventory generated using automated tools
+- [ ] **Gate A2**: User scope selection documented (if large codebase)
+- [ ] **Gate A3**: File + Pattern checklists created
+- **ENFORCEMENT**: Cannot proceed to Performance phase until ALL Analysis gates pass
+
+#### Performance Phase Gates  
+- [ ] **Gate P1**: Every file in scope addressed in optimization log
+- [ ] **Gate P2**: Infrastructure changes implemented where required
+- [ ] **Gate P3**: No phantom optimizations claimed
+- **ENFORCEMENT**: Cannot proceed to Verification phase until ALL Performance gates pass
+
+#### Verification Phase Gates
+- [ ] **Gate V1**: File coverage validation completed
+- [ ] **Gate V2**: All gaps identified and resolved  
+- [ ] **Gate V3**: Final accuracy validation passed
+- **ENFORCEMENT**: Cannot mark session complete until ALL Verification gates pass
+
+---
+
+## Validation Commands - MANDATORY USAGE
+
+### File Inventory Validation
+```bash
+# REQUIRED: Generate actual file list
+find /project/path -name "*.al" -type f | sort
+# OR
+glob **/*.al
+```
+
+### Coverage Cross-Reference
+```bash  
+# REQUIRED: Validate optimization claims
+grep -r "filename.al" optimization-log.md
+# Cross-reference against actual files
+```
+
+### Gap Detection
+```bash
+# REQUIRED: Identify missing files
+diff planned-files.txt actual-files.txt
+# Any differences = BLOCKING CONDITION
+```
+
+---
+
+## Agent Behavior Enforcement
+
+### FORBIDDEN Agent Actions
+- ❌ **Claiming "100% complete"** without verification phase
+- ❌ **Skipping file inventory generation**
+- ❌ **Making optimization claims for non-existent files**
+- ❌ **Proceeding without gate validation**
+- ❌ **Marking any phase complete with known gaps**
+
+### REQUIRED Agent Actions  
+- ✅ **Generate file lists using automated tools**
+- ✅ **Cross-reference ALL claims against actual files**
+- ✅ **Document EVERY gate passage explicitly**
+- ✅ **Stop and request gap resolution when validation fails**
+- ✅ **Execute verification phase for EVERY session**
+
+---
+
+## Session Validation Checklist
+
+### Before Marking ANY Session Complete:
+- [ ] **Analysis phase**: All gates documented as passed
+- [ ] **Performance phase**: All gates documented as passed  
+- [ ] **Verification phase**: Executed and all gates passed
+- [ ] **File inventory**: Generated using automated tools and validated
+- [ ] **Coverage gaps**: Zero unresolved gaps remaining
+- [ ] **Accuracy validation**: All optimization claims verified against actual files
+
+### Session INVALID If:
+- Any phase skipped
+- Any gate bypassed without documentation
+- Any phantom optimizations claimed
+- Any files in scope left unaddressed
+- Verification phase not executed
+
+---
+
+## Quality Assurance Requirements
+
+### Documentation Standards
+- **File references**: Must include exact file paths that exist
+- **Line references**: Must reference actual line numbers in files
+- **Optimization claims**: Must be verifiable by examining actual code
+- **Coverage claims**: Must be backed by file inventory validation
+
+### Validation Evidence Required
+- **Actual file lists**: Generated by automated tools, not manual entry  
+- **Cross-reference results**: Showing planned vs actual analysis coverage
+- **Gap resolution**: Documentation of how ALL identified gaps were resolved
+- **Accuracy verification**: Evidence that claimed optimizations actually exist
+
+---
+
+## Enforcement Violations - Session Restart Required
+
+### Major Violations (Restart Entire Session):
+- Phantom file optimizations claimed
+- Verification phase completely skipped
+- Major coverage gaps discovered in verification
+
+### Minor Violations (Restart Current Phase):
+- Gate bypassed without documentation
+- File inventory not generated using automated tools  
+- Optimization claims not cross-referenced
+
+---
+
+## Success Criteria - ALL MUST BE MET
+
+✅ **Phase Sequence**: Analysis → Performance → Verification completed in order  
+✅ **Gate Compliance**: ALL gates passed and documented  
+✅ **File Accuracy**: Zero phantom files, zero missing files in scope  
+✅ **Validation Evidence**: Automated tools used for all inventory and validation  
+✅ **Gap Resolution**: ALL coverage gaps identified and resolved  
+✅ **Quality Assurance**: All optimization claims verified against actual code
+
+**Only sessions meeting ALL criteria are considered valid and complete.**

package/embedded-knowledge/methodologies/workflows/code-review-workflow.md

@@ -0,0 +1,99 @@
+---
+type: workflow
+category: quality-assurance
+name: bc-code-review-workflow
+workflow_type: checklist
+phases:
+  - name: preparation
+    title: "Pre-Review Preparation"
+    required: true
+    tasks:
+      - "Ensure all tests pass"
+      - "Run static analysis tools"
+      - "Check code formatting compliance"
+      - "Verify documentation is updated"
+  - name: performance-review
+    title: "Performance Analysis"
+    required: true
+    tasks:
+      - "Check for SetLoadFields usage"
+      - "Verify efficient query patterns"
+      - "Validate SIFT usage for summations"
+      - "Review loop efficiency"
+      - "Check for unnecessary CalcFields calls"
+  - name: security-review
+    title: "Security & Validation"
+    required: true
+    tasks:
+      - "Validate user input handling"
+      - "Check permission requirements"
+      - "Review error handling"
+      - "Verify data validation"
+  - name: maintainability
+    title: "Code Maintainability"
+    required: false
+    tasks:
+      - "Check naming conventions"
+      - "Review code complexity"
+      - "Validate commenting"
+      - "Assess testability"
+related_topics:
+  - code-quality-standards
+  - performance-review-checklist
+  - security-best-practices
+domains: [quality-assurance, performance, security]
+difficulty: intermediate
+estimated_duration: "30-45 minutes"
+prerequisites: ["Basic AL knowledge", "Understanding of BC architecture"]
+tags: [workflow, code-review, quality-assurance, checklist]
+---
+
+# Business Central Code Review Workflow
+
+## Overview
+A systematic approach to reviewing AL code for Business Central extensions, focusing on performance, security, and maintainability.
+
+## Workflow Phases
+
+### 1. Pre-Review Preparation (Required)
+Before starting the review, ensure:
+- [ ] All automated tests pass
+- [ ] Static analysis tools show no critical issues
+- [ ] Code follows formatting standards
+- [ ] Documentation reflects changes
+
+### 2. Performance Analysis (Required)
+Critical performance checks:
+- [ ] **SetLoadFields**: Used before FindSet() when only specific fields needed
+- [ ] **Query Patterns**: Efficient use of SetRange, SetFilter, SetCurrentKey
+- [ ] **SIFT Usage**: CalcSums instead of manual summation loops
+- [ ] **Loop Efficiency**: Minimal processing inside repeat-until loops
+- [ ] **CalcFields**: Batched rather than individual calls
+
+### 3. Security & Validation (Required)
+Security-focused review:
+- [ ] **Input Validation**: All user inputs properly validated
+- [ ] **Permissions**: Appropriate permission sets required
+- [ ] **Error Handling**: Graceful error handling without data exposure
+- [ ] **Data Validation**: Business rules properly enforced
+
+### 4. Code Maintainability (Optional)
+Quality improvements:
+- [ ] **Naming**: Clear, consistent naming conventions
+- [ ] **Complexity**: Functions under 50 lines, minimal nesting
+- [ ] **Comments**: Complex logic explained
+- [ ] **Testability**: Code structure supports unit testing
+
+## Review Checklist Tools
+Use these questions for each phase:
+
+**Performance**: "Will this code perform well with 10,000+ records?"
+**Security**: "What happens if a malicious user provides unexpected input?"
+**Maintainability**: "Can another developer understand this in 6 months?"
+
+## Common Issues to Flag
+- Manual summation loops (use CalcSums)
+- Missing SetLoadFields on large datasets
+- Hardcoded values that should be configurable
+- Missing error handling on external calls
+- Complex nested logic without comments