fix: Simplify pattern (#3)

* fix: simplify include pattern

* chore: add new ci

* update repo settings

* fix: improve accept string or list

* chore: update repos settings

* fix: update workflow prompt

Author: daniel-butler-irl

.github/settings.yml

@@ -5,7 +5,7 @@
 # any change of this settings.yml file is detected by the GitHub App and
 # the settings of this repository are updated immediately.
 #
-_extends: repo-settings:.github/common-settings-v2.yml
+_extends: repo-settings:.github/common-pipeline-settings.yml
 
 # repo-specific settings
 #

.github/workflows/ci.yml

@@ -8,8 +8,5 @@ on:
 
 jobs:
   call-terraform-ci-pipeline:
-    uses: terraform-ibm-modules/common-pipeline-assets/.github/workflows/common-terraform-module-ci-v2.yml@v1.22.5
+    uses: terraform-ibm-modules/common-pipeline-assets/.github/workflows/common-python-ci.yml@v1.23.0
     secrets: inherit
-    with:
-      craSCCv2: true
-      craConfigYamlFile: "cra-config.yaml"

test/test_parameter_sanitization.py

@@ -14,11 +14,12 @@ class TestParameterSanitization:
     """Test cases for parameter sanitization."""
 
     def test_sanitize_valid_list(self):
-        """Test sanitization preserves valid lists."""
+        """Test sanitization of lists with mixed patterns."""
         input_list = [".*\\.tf$", ".*\\.md$", "main.tf"]
         result = _sanitize_list_parameter(input_list, "test_param")
-        assert result == input_list
-        assert result is input_list  # Should return the same object
+        # main.tf is detected as a glob pattern and converted to regex
+        expected = [".*\\.tf$", ".*\\.md$", "main\\.tf$"]
+        assert result == expected
 
     def test_sanitize_none(self):
         """Test sanitization handles None correctly."""
@@ -30,7 +31,7 @@ def test_sanitize_empty_list(self):
         input_list = []
         result = _sanitize_list_parameter(input_list, "test_param")
         assert result == []
-        assert result is input_list  # Should return the same object
+        # Note: result may not be the same object due to pattern processing
 
     def test_sanitize_json_string(self):
         """Test sanitization converts JSON strings to lists."""
@@ -40,10 +41,10 @@ def test_sanitize_json_string(self):
         expected = [".*\\.tf$", ".*\\.md$"]
         assert result == expected
 
-        # Test with single item
+        # Test with single item (glob pattern gets converted)
         json_str = '["main.tf"]'
         result = _sanitize_list_parameter(json_str, "test_param")
-        assert result == ["main.tf"]
+        assert result == ["main\\.tf$"]
 
         # Test with empty array
         json_str = "[]"
@@ -52,12 +53,14 @@ def test_sanitize_json_string(self):
 
     def test_sanitize_single_string(self):
         """Test sanitization converts single strings to lists."""
+        # Glob patterns get converted to regex
         result = _sanitize_list_parameter("*.tf", "test_param")
-        assert result == ["*.tf"]
+        assert result == [".*\\.tf$"]
 
         result = _sanitize_list_parameter("main.tf", "test_param")
-        assert result == ["main.tf"]
+        assert result == ["main\\.tf$"]
 
+        # Regex patterns are preserved
         result = _sanitize_list_parameter(".*\\.tf$", "test_param")
         assert result == [".*\\.tf$"]
 
@@ -109,9 +112,12 @@ def test_sanitize_whitespace_handling(self):
         result = _sanitize_list_parameter(json_str, "test_param")
         assert result == [".*\\.tf$", ".*\\.md$"]
 
-        # Regular string with whitespace
+        # Regular string with whitespace (treated as glob pattern with spaces)
         result = _sanitize_list_parameter("  *.tf  ", "test_param")
-        assert result == ["  *.tf  "]  # Should preserve whitespace in content
+        # Glob conversion will preserve the whitespace but convert to regex
+        assert len(result) == 1
+        assert result[0].endswith("$")
+        assert "tf" in result[0]
 
     def test_sanitize_complex_patterns(self):
         """Test sanitization with complex regex patterns."""
@@ -132,3 +138,77 @@ def test_sanitize_complex_patterns(self):
         json_str = json.dumps(patterns)
         result = _sanitize_list_parameter(json_str, "test_param")
         assert result == patterns
+
+    def test_glob_pattern_conversion(self):
+        """Test automatic conversion of glob patterns to regex."""
+        # Test basic glob patterns
+        glob_patterns = ["*.tf", "*.md", "main.tf"]
+        result = _sanitize_list_parameter(glob_patterns, "test_param")
+
+        # Should convert to regex patterns
+        expected = [".*\\.tf$", ".*\\.md$", "main\\.tf$"]
+        assert result == expected
+
+    def test_mixed_glob_and_regex_patterns(self):
+        """Test handling of mixed glob and regex patterns."""
+        mixed_patterns = ["*.tf", ".*\\.py$", "README.md", "^test.*\\.js$"]
+        result = _sanitize_list_parameter(mixed_patterns, "test_param")
+
+        # Only glob patterns should be converted
+        expected = [".*\\.tf$", ".*\\.py$", "README\\.md$", "^test.*\\.js$"]
+        assert result == expected
+
+    def test_complex_glob_patterns(self):
+        """Test complex glob patterns with wildcards."""
+        glob_patterns = ["examples/*.tf", "modules/*/main.tf", "*.{tf,py}"]
+        result = _sanitize_list_parameter(glob_patterns, "test_param")
+
+        # Should convert appropriately
+        assert all(pattern.endswith("$") for pattern in result)
+        assert "examples/" in result[0]
+        assert "modules/" in result[1]
+
+    def test_glob_pattern_detection(self):
+        """Test the glob pattern detection logic."""
+        from tim_mcp.server import _is_glob_pattern
+
+        # These should be detected as glob patterns
+        assert _is_glob_pattern("*.tf") is True
+        assert _is_glob_pattern("main.tf") is True
+        assert _is_glob_pattern("examples/*.py") is True
+        assert _is_glob_pattern("test?.md") is True
+
+        # These should be detected as regex patterns
+        assert _is_glob_pattern(".*\\.tf$") is False
+        assert _is_glob_pattern("^main\\.tf$") is False
+        assert _is_glob_pattern("[abc].tf") is False
+        assert _is_glob_pattern("test\\.py") is False
+
+    def test_glob_to_regex_conversion(self):
+        """Test the glob to regex conversion function."""
+        from tim_mcp.server import _convert_glob_to_regex
+
+        # Test basic conversions
+        assert _convert_glob_to_regex("*.tf") == ".*\\.tf$"
+        assert _convert_glob_to_regex("main.tf") == "main\\.tf$"
+        assert _convert_glob_to_regex("test?.py") == "test.\\.py$"
+
+        # Test path patterns
+        result = _convert_glob_to_regex("examples/*.tf")
+        assert "examples" in result
+        assert result.endswith("$")
+
+    def test_single_glob_string_conversion(self):
+        """Test conversion of single glob pattern string."""
+        result = _sanitize_list_parameter("*.tf", "test_param")
+        assert result == [".*\\.tf$"]
+
+        result = _sanitize_list_parameter("main.py", "test_param")
+        assert result == ["main\\.py$"]
+
+    def test_json_string_with_glob_patterns(self):
+        """Test JSON string containing glob patterns."""
+        json_str = '["*.tf", "*.md"]'
+        result = _sanitize_list_parameter(json_str, "test_param")
+        expected = [".*\\.tf$", ".*\\.md$"]
+        assert result == expected