refactor: remove PlainTextBackend and enhance testing infrastructure

- Remove PlainTextBackend and its tests
- Add Python 3.12 support
- Set up SonarCloud integration
- Update test configuration
  - Centralize coverage config in pyproject.toml
  - Simplify tox configuration
  - Add quality gates
- Add Architecture Decision Records (ADRs)
- Update design documentation
- Add development tasks tracking
- Update .gitignore for IDE settings

Author: ritwik-g

.github/workflows/test.yml

@@ -12,10 +12,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ['3.9', '3.10', '3.11']
+        python-version: ['3.9', '3.10', '3.11', '3.12']
 
     steps:
     - uses: actions/checkout@v3
+      with:
+        fetch-depth: 0  # Shallow clones should be disabled for better relevancy of analysis
 
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v4
@@ -25,7 +27,19 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install tox tox-gh-actions
+        pip install tox tox-gh-actions pylint
+
+    - name: Run pylint
+      run: |
+        pylint helm_values_manager --output-format=text:pylint-report.txt,colorized
+      continue-on-error: true  # Don't fail if pylint has warnings
 
     - name: Test with tox
       run: tox
+
+    - name: SonarCloud Scan
+      if: matrix.python-version == '3.12'  # Only run once, on the latest Python version
+      uses: SonarSource/sonarcloud-github-action@master
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.gitignore

@@ -167,6 +167,12 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 
+# IDE settings
+.vscode/
+.idea/
+*.sublime-workspace
+*.sublime-project
+
 # PyPI configuration file
 .pypirc
 

docs/ADR/002-config-path-and-storage-design.md

@@ -0,0 +1,112 @@
+# ADR 002: Config Path and Storage Design
+
+## Status
+Accepted
+
+## Context
+When implementing the Helm Values Manager, we identified several key design considerations:
+
+1. Users need to define configuration structure (paths, descriptions, requirements) independently of setting values
+2. As a CLI plugin, each command is executed independently, requiring consistent file operations
+3. The initial design included a PlainText backend which added unnecessary complexity
+4. Path lookups and validations needed optimization for better performance
+
+## Decision
+
+### 1. Separate Config Definition from Values
+- Allow users to define configuration paths and metadata without setting values
+- Support metadata like description, required flag, and sensitivity flag
+- Enable validation of structure before any values are set
+
+### 2. Standardized Command Pattern
+- Implement a BaseCommand class for consistent file operations
+- Include file locking to prevent concurrent modifications
+- Add automatic backup before writes
+- Handle common error scenarios uniformly
+
+```python
+class BaseCommand:
+    def execute(self):
+        try:
+            config = self.load_config()
+            result = self.run(config)
+            self.save_config(config)
+            return result
+        except Exception as e:
+            # Handle errors, cleanup
+            raise
+```
+
+### 3. Simplified Storage Design
+- Remove PlainTextBackend
+- Store local values directly in HelmValuesConfig
+- Use specialized backends (AWS, Azure) only for remote storage
+- Maintain clear separation between local and remote storage
+
+### 4. Optimized Path Management
+- Implement a path map for O(1) lookups
+- Validate path uniqueness during definition
+- Store local values with efficient key structure
+- Separate path definition from value storage
+
+```python
+class HelmValuesConfig:
+    def __init__(self):
+        self._path_map = {}      # Fast path lookups
+        self._local_values = {}  # Local value storage
+```
+
+## Consequences
+
+### Positive
+1. **Better User Experience**
+   - Clear separation between structure definition and value setting
+   - Improved validation capabilities
+   - More intuitive configuration management
+
+2. **Improved Performance**
+   - O(1) path lookups
+   - Reduced complexity in local storage
+   - More efficient validation
+
+3. **Enhanced Maintainability**
+   - Consistent command pattern
+   - Clear separation of concerns
+   - Simplified storage architecture
+
+4. **Better Safety**
+   - Built-in file locking
+   - Automatic backups
+   - Strict path validation
+
+### Negative
+1. **Additional Complexity**
+   - New base command pattern to learn
+   - More sophisticated path management
+
+## Implementation Notes
+
+1. **Command Implementation**
+```python
+class SetValueCommand(BaseCommand):
+    def run(self, config):
+        config.set_value(self.path, self.env, self.value)
+```
+
+2. **Path Definition**
+```python
+config.add_config_path(
+    path="app.replicas",
+    description="Number of application replicas",
+    required=True
+)
+```
+
+3. **Value Storage**
+```python
+# Local storage
+config.set_value("app.replicas", "dev", "3")
+
+# Remote storage (AWS/Azure)
+config.set_value("app.secrets.key", "prod", "secret-value")
+```

docs/ADR/003-unified-path-value-storage.md

@@ -0,0 +1,110 @@
+# ADR 003: Unified Path and Value Storage
+
+## Status
+Accepted
+
+## Context
+In our previous design (ADR 002), we had two separate dictionaries in `HelmValuesConfig`:
+1. `_path_map` for storing path metadata and validation
+2. `_local_values` for storing local values
+
+This separation added unnecessary complexity and potential for inconsistency.
+
+## Decision
+
+### 1. Unified Storage Structure
+We will use a single dictionary with a nested structure:
+
+```python
+_path_map = {
+    "app.replicas": {  # path
+        "metadata": {
+            "description": "Number of replicas",
+            "required": True,
+            "sensitive": False
+        },
+        "values": {
+            "dev": "3",  # local value
+            "prod": ValueBackend  # remote value
+        }
+    }
+}
+```
+
+### 2. Value Resolution Strategy
+- Local values are stored directly in the values dict
+- Remote values are represented by their respective backend instances
+- The get_value method will automatically resolve the appropriate storage
+
+```python
+def get_value(self, path: str, environment: str) -> str:
+    if path not in self._path_map:
+        raise PathNotFoundError(f"Path not defined: {path}")
+
+    env_values = self._path_map[path]["values"]
+    if environment not in env_values:
+        raise ValueError(f"No value set for {path} in {environment}")
+
+    value = env_values[environment]
+    if isinstance(value, ValueBackend):
+        return value.get_value(self._generate_key(path, environment))
+    return value
+```
+
+## Consequences
+
+### Positive
+1. **Simplified Data Structure**
+   - Single source of truth for paths and values
+   - Clearer relationship between paths and their values
+   - More intuitive code organization
+
+2. **Better Performance**
+   - Single lookup for both metadata and values
+   - Reduced memory usage
+   - Simpler caching if needed
+
+3. **Improved Maintainability**
+   - Less code to maintain
+   - Fewer potential points of failure
+   - Easier to understand and debug
+
+### Negative
+1. **More Complex Value Resolution**
+   - Need to check value type before resolving
+   - Slightly more complex serialization/deserialization
+
+## Implementation Notes
+
+1. **Path Definition**
+```python
+config.add_config_path(
+    path="app.replicas",
+    description="Number of replicas",
+    required=True
+)
+```
+
+2. **Value Setting**
+```python
+# Setting local value
+config.set_value("app.replicas", "dev", "3")
+
+# Setting remote value (automatically creates backend)
+config.set_value("app.secrets.key", "prod", "secret-value")
+```
+
+3. **Serialization**
+```python
+def to_dict(self) -> dict:
+    result = {}
+    for path, data in self._path_map.items():
+        result[path] = {
+            "metadata": data["metadata"],
+            "values": {
+                env: value if not isinstance(value, ValueBackend) else None
+                for env, value in data["values"].items()
+            }
+        }
+    return result
+```