@ngocsangairvds/vsaf 3.1.27 → 3.2.1

package/tools/vds-scripts/scripts/update_modules_xml.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+Script to update the IntelliJ IDEA modules.xml file with all VDS projects.
+This makes it easier to work with the monorepo as a multi-project workspace.
+"""
+
+import os
+import xml.etree.ElementTree as ET
+
+# Define the project structure
+PROJECT_GROUPS = {
+    "LEP-Project": [
+        "document-management",
+        "document-mgmt", 
+        "file-management",
+        "lending-application-service",
+        "lending-basecode",
+        "lending-channel-mgmt",
+        "lending-cms-be",
+        "lending-cms-fe",
+        "lending-customer-screening-service",
+        "lending-customer-service",
+        "lending-decision-service",
+        "lending-ekyc-business",
+        "lending-ekyc-service",
+        "lending-event-backbone",
+        "lending-lender-process",
+        "lending-lender-service",
+        "lending-limit-mgmt",
+        "lending-miniapp-fe",
+        "lending-notification-service",
+        "lending-payment-service",
+        "lending-product-mgmt",
+        "lending-reconcile-service",
+        "lending-refund-service",
+        "lending-reminder-process"
+    ],
+    "INSURANCE-Project": [
+        "insurance-authentication-sync-process",
+        "insurance-auto-underwriting-process",
+        "insurance-centralized-sync-service",
+        "insurance-claim-business",
+        "insurance-cms-be",
+        "insurance-common",
+        "insurance-customer-business",
+        "insurance-customer-webview",
+        "insurance-insurer-service",
+        "insurance-job-scheduler",
+        "insurance-notification-spi",
+        "insurance-ocr-service",
+        "insurance-payment-service",
+        "insurance-payment-service-v2",
+        "insurance-policy-business",
+        "insurance-promotion-business",
+        "insurance-proposal-business",
+        "insurance-reconcile-process",
+        "insurance-renewal-process",
+        "insurance-socialized-insurance-service",
+        "insurance-timeout-process"
+    ],
+    "SAVING-Project": [
+        "saving-account",
+        "saving-business",
+        "saving-features-management",
+        "saving-job-management",
+        "saving-order",
+        "saving-promotion",
+        "saving-refund-process",
+        "saving-spi",
+        "saving-timeout-process",
+        "saving-transaction"
+    ],
+    "EKYC-Project": [
+        "ekyc-business",
+        "ekyc-service"
+    ],
+    "Infrastructure": [
+        "VDS-AI-Memory",
+        "vds-scripts"
+    ],
+    "Documentation": [
+        "docs-nttc"
+    ]
+}
+
+def update_modules_xml(vds_root):
+    """
+    Update the IntelliJ IDEA modules.xml file with all projects.
+    """
+    # Path to modules.xml
+    modules_xml_path = os.path.join(vds_root, ".idea", "modules.xml")
+    
+    # Parse existing modules.xml
+    try:
+        tree = ET.parse(modules_xml_path)
+        root = tree.getroot()
+    except FileNotFoundError:
+        # Create new modules.xml if it doesn't exist
+        root = ET.Element("project", {"version": "4"})
+        component = ET.SubElement(root, "component", {"name": "ProjectModuleManager"})
+        modules = ET.SubElement(component, "modules")
+        tree = ET.ElementTree(root)
+    
+    # Find the modules element
+    modules_element = root.find(".//modules")
+    if modules_element is None:
+        component = root.find(".//component[@name='ProjectModuleManager']")
+        if component is None:
+            component = ET.SubElement(root, "component", {"name": "ProjectModuleManager"})
+        modules_element = ET.SubElement(component, "modules")
+    
+    # Clear existing VDS module entries (but keep the main vds.iml)
+    existing_modules = modules_element.findall("module")
+    for module in existing_modules:
+        file_path = module.get("filepath", "")
+        # Remove any existing VDS project module entries to avoid duplicates
+        if any(project_dir in file_path for project_dir in [
+            "LEP-project", "INSURANCE-project", "SAVING-project", "EKYC-project",
+            "VDS-AI-Memory", "vds-scripts", "docs-nttc"
+        ]):
+            modules_element.remove(module)
+    
+    # Add modules for each project
+    for group_name, projects in PROJECT_GROUPS.items():
+        for project in projects:
+            # Construct the module file path
+            if project in ["VDS-AI-Memory", "vds-scripts", "docs-nttc"]:
+                # These are top-level directories
+                module_file_path = f"$PROJECT_DIR$/{project}/.idea/{project}.iml"
+                module_file_url = f"file://$PROJECT_DIR$/{project}/.idea/{project}.iml"
+            else:
+                # These are in project directories
+                module_file_path = f"$PROJECT_DIR$/{group_name.split('-')[0]}-project/{project}/{project}.iml"
+                module_file_url = f"file://$PROJECT_DIR$/{group_name.split('-')[0]}-project/{project}/{project}.iml"
+            
+            # Check if module entry already exists
+            existing = False
+            for module in modules_element.findall("module"):
+                if module.get("filepath") == module_file_path:
+                    existing = True
+                    break
+            
+            # Add module entry if it doesn't exist
+            if not existing:
+                module_element = ET.SubElement(modules_element, "module", {
+                    "fileurl": module_file_url,
+                    "filepath": module_file_path,
+                    "group": group_name
+                })
+    
+    # Write updated modules.xml with proper formatting
+    # Create a temporary file with proper formatting
+    temp_file = modules_xml_path + ".tmp"
+    tree.write(temp_file, encoding="UTF-8", xml_declaration=True)
+    
+    # Read and format the XML properly
+    with open(temp_file, 'r') as f:
+        content = f.read()
+    
+    # Parse and reformat with proper indentation
+    import xml.dom.minidom
+    dom = xml.dom.minidom.parseString(content)
+    pretty_xml = dom.toprettyxml(indent="  ")
+    
+    # Remove extra blank lines
+    lines = [line for line in pretty_xml.split('\n') if line.strip()]
+    pretty_xml = '\n'.join(lines)
+    
+    with open(modules_xml_path, 'w') as f:
+        f.write(pretty_xml)
+    
+    # Remove temporary file
+    os.remove(temp_file)
+            
+    print(f"Updated modules.xml: {modules_xml_path}")
+
+def main():
+    """
+    Main function to update modules.xml.
+    """
+    vds_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+    
+    print(f"Updating IntelliJ IDEA modules.xml in: {vds_root}")
+    
+    update_modules_xml(vds_root)
+    
+    print("modules.xml update complete!")
+
+if __name__ == "__main__":
+    main()

package/tools/vds-scripts/scripts/uv-workspace-alignment-verification-2026-03-25.md

@@ -0,0 +1,128 @@
+# Scripts UV Workspace Alignment Verification Note
+
+Date: 2026-03-25
+Branch: `feat/scripts-uv-workspace-alignment`
+Scope: helper/bootstrap/script-shell alignment for `WHO-project/vds-scripts/scripts/`
+
+## Summary
+
+This note records the bounded verification run for the current implementation lane.
+The purpose is to prove that the updated shell contract works across the main
+contexts called out by the spec:
+
+- clean shell execution
+- polluted parent environment execution
+- non-standard nested caller path execution
+
+It also records one helper portability fix discovered during verification.
+
+## Verified contract
+
+The current intended contract is:
+
+- maintained scripts use `scripts/worktree_uv.sh` through `scripts/vds_sh_helpers.sh`
+- helper-driven invocations bind the workspace explicitly with `--directory <vds-scripts-root>`
+- helper-driven package targeting resolves workspace member directories to uv project names for `--package`
+- canonical integrated bootstrap assumes Python 3.14+
+
+## Three-context regression matrix
+
+### Context 1 — clean shell
+
+Command class verified:
+- helper-driven spec package help surface
+
+Observed result:
+- passed
+
+Notes:
+- `vds_uv_run_package spec_orchestrator vds-spec --help` succeeded from the implementation worktree with no inherited environment state.
+
+### Context 2 — polluted parent environment
+
+Command class verified:
+- helper-driven routed CLI command with fake parent environment values
+
+Injected environment:
+- `VIRTUAL_ENV=/tmp/fake-venv`
+- `UV_PROJECT_ENVIRONMENT=/tmp/fake-project-env`
+- `CONDA_PREFIX=/tmp/fake-conda`
+
+Observed result:
+- passed
+
+Notes:
+- `vds_uv_run_package vds_cli vds-cli doctor` succeeded.
+- The wrapper/helper path remained functional despite the polluted parent environment.
+
+### Context 3 — non-standard nested caller path
+
+Command class verified:
+- targeted sync helper script launched from `scripts/target-state-automation/`
+
+Observed result:
+- passed
+
+Notes:
+- `UV_SYNC_FLAGS=--dry-run ./update_dependencies.sh` succeeded when launched from the nested target-state-automation directory.
+- This confirms root resolution and wrapper binding do not depend on the older hardcoded 4-level traversal pattern.
+
+## Additional bounded verification already passed in this lane
+
+Previously verified in this worktree:
+
+- helper-driven `vds-spec --help`
+- helper-driven `vds-cli status`
+- helper-driven `vds-cli doctor`
+- helper-driven `vds-markdown --help`
+- targeted bootstrap dry-run
+- full bootstrap dry-run
+- updated shell scripts syntax-check cleanly
+
+## Helper portability fix discovered during verification
+
+### Issue
+
+The initial helper implementation used host `python3` plus `tomllib` to resolve
+workspace member directory names to uv package names.
+
+That failed in a shell path where `python3` did not provide `tomllib`.
+
+### Fix
+
+The helper was updated to parse `[project].name` from member `pyproject.toml`
+using shell/awk logic instead of host Python.
+
+### Outcome
+
+Package-name resolution no longer depends on a host Python 3.11+ runtime just to
+run the shell helper layer.
+
+## Known follow-up outside helper-layer closure
+
+### `scripts/target-state-automation/validate_schemas.sh`
+
+The script now routes through the helper correctly, but the underlying schema
+command shape appears stale relative to the current `vds-cli schema` /
+`vds-schema-convert` compatibility surface.
+
+The script has therefore been updated to fail explicitly and truthfully with a
+clear follow-up message instead of forwarding operators into a stale command and
+producing a confusing CLI option error.
+
+This remains classified as:
+- schema-command drift follow-up
+- not a helper-layer regression
+
+## Closure assessment for this lane
+
+For the shell/uv alignment scope covered by this branch:
+- helper consolidation: complete
+- bootstrap alignment: complete
+- maintained script migration in scope: complete
+- docs alignment in scope: complete
+- three-context regression matrix: complete
+
+This branch is ready for review/merge for the intended helper/bootstrap/docs
+alignment scope, with `validate_schemas.sh` command-surface drift explicitly
+left as separate follow-up work.

package/tools/vds-scripts/scripts/validate_brd_coverage.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+BRD Coverage Validation Script
+Validates that all required BRD sections (3.1-3.5 and 4.1-4.11) are mapped to services.
+"""
+
+import os
+import re
+from pathlib import Path
+from typing import Dict, List, Set
+import json
+
+# Required BRD sections
+REQUIRED_BRD_SECTIONS = [
+    # Customer features
+    "3.1", "3.2", "3.3", "3.4", "3.5",
+    # Admin features  
+    "4.1", "4.2", "4.3", "4.4", "4.5", "4.6", "4.7", "4.8", "4.9", "4.10", "4.11"
+]
+
+# High-priority services with known BRD mappings
+HIGH_PRIORITY_SERVICES = {
+    "insurance-policy-business": ["3.4", "4.5"],
+    "insurance-proposal-business": ["3.3.5", "3.3.6", "3.3.7", "3.3.8"],
+    "insurance-claim-business": ["3.5", "4.6"],
+    "insurance-customer-business": ["3.1", "3.2", "4.4"],
+    "insurance-product-catalog": ["4.3", "4.3.1"],
+    "insurance-rating-engine": ["3.3.5", "4.3.3"],
+    "insurance-renewal-process": ["3.4.2", "3.4.3", "3.4.4"]
+}
+
+def find_brd_references_in_file(file_path: Path) -> Set[str]:
+    """Find all BRD section references in a file."""
+    brd_refs = set()
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+            
+        # Pattern to match BRD references like "3.1", "4.5", "3.3.5", etc.
+        pattern = r'BRD.*?([34]\.\d+(?:\.\d+)*)'
+        matches = re.findall(pattern, content, re.IGNORECASE)
+        
+        for match in matches:
+            brd_refs.add(match)
+            
+    except Exception as e:
+        print(f"Error reading {file_path}: {e}")
+        
+    return brd_refs
+
+def scan_documentation_for_brd_refs(docs_root: Path) -> Dict[str, Set[str]]:
+    """Scan all documentation files for BRD references."""
+    brd_coverage = {}
+    
+    # Scan markdown files
+    for md_file in docs_root.rglob("*.md"):
+        if md_file.is_file():
+            refs = find_brd_references_in_file(md_file)
+            if refs:
+                relative_path = str(md_file.relative_to(docs_root))
+                brd_coverage[relative_path] = refs
+                
+    return brd_coverage
+
+def validate_brd_coverage() -> Dict:
+    """Validate BRD coverage completeness."""
+    
+    # Get the documentation root
+    script_dir = Path(__file__).parent
+    docs_root = script_dir.parent / "insurance-document"
+    
+    if not docs_root.exists():
+        docs_root = script_dir.parent.parent / "insurance-document"
+    
+    if not docs_root.exists():
+        print(f"❌ Documentation root not found at {docs_root}")
+        return {"error": "Documentation root not found"}
+    
+    print(f"🔍 Scanning documentation at: {docs_root}")
+    
+    # Scan for BRD references
+    brd_coverage = scan_documentation_for_brd_refs(docs_root)
+    
+    # Collect all found BRD sections
+    found_sections = set()
+    for file_refs in brd_coverage.values():
+        found_sections.update(file_refs)
+    
+    # Check coverage
+    required_sections = set(REQUIRED_BRD_SECTIONS)
+    covered_sections = set()
+    
+    # Map found sections to required sections
+    for found in found_sections:
+        for required in required_sections:
+            if found.startswith(required):
+                covered_sections.add(required)
+    
+    missing_sections = required_sections - covered_sections
+    
+    # Generate report
+    report = {
+        "total_required": len(required_sections),
+        "total_covered": len(covered_sections),
+        "coverage_percentage": (len(covered_sections) / len(required_sections)) * 100,
+        "covered_sections": sorted(list(covered_sections)),
+        "missing_sections": sorted(list(missing_sections)),
+        "found_references": dict((k, sorted(list(v))) for k, v in brd_coverage.items()),
+        "high_priority_services": HIGH_PRIORITY_SERVICES
+    }
+    
+    return report
+
+def print_coverage_report(report: Dict):
+    """Print a formatted coverage report."""
+    
+    if "error" in report:
+        print(f"❌ {report['error']}")
+        return
+    
+    print("\n" + "="*60)
+    print("📊 BRD COVERAGE VALIDATION REPORT")
+    print("="*60)
+    
+    print(f"\n📈 Coverage Summary:")
+    print(f"   Total Required Sections: {report['total_required']}")
+    print(f"   Covered Sections: {report['total_covered']}")
+    print(f"   Coverage Percentage: {report['coverage_percentage']:.1f}%")
+    
+    if report['coverage_percentage'] >= 100:
+        print("   ✅ 100% BRD coverage achieved!")
+    elif report['coverage_percentage'] >= 80:
+        print("   ⚠️  Good coverage, but some sections missing")
+    else:
+        print("   ❌ Insufficient BRD coverage")
+    
+    print(f"\n✅ Covered Sections ({len(report['covered_sections'])}):")
+    for section in report['covered_sections']:
+        print(f"   • {section}")
+    
+    if report['missing_sections']:
+        print(f"\n❌ Missing Sections ({len(report['missing_sections'])}):")
+        for section in report['missing_sections']:
+            print(f"   • {section}")
+    
+    print(f"\n🔍 High-Priority Service Mappings:")
+    for service, sections in report['high_priority_services'].items():
+        print(f"   • {service}: {', '.join(sections)}")
+    
+    print(f"\n📁 Files with BRD References ({len(report['found_references'])}):")
+    for file_path, refs in list(report['found_references'].items())[:10]:  # Show first 10
+        print(f"   • {file_path}: {', '.join(refs)}")
+    
+    if len(report['found_references']) > 10:
+        print(f"   ... and {len(report['found_references']) - 10} more files")
+
+if __name__ == "__main__":
+    print("🚀 Starting BRD Coverage Validation...")
+    report = validate_brd_coverage()
+    print_coverage_report(report)
+    
+    # Save report to file
+    script_dir = Path(__file__).parent
+    report_file = script_dir / "brd_coverage_report.json"
+    
+    with open(report_file, 'w') as f:
+        json.dump(report, f, indent=2)
+    
+    print(f"\n💾 Report saved to: {report_file}")
+    
+    # Exit with appropriate code
+    if "error" in report:
+        exit(1)
+    elif report['coverage_percentage'] < 100:
+        print(f"\n⚠️  BRD coverage incomplete: {report['coverage_percentage']:.1f}%")
+        exit(1)
+    else:
+        print(f"\n✅ BRD coverage validation passed: {report['coverage_percentage']:.1f}%")
+        exit(0)