change project name helmpy -> helm-sdkpy

Author: jamesbeedy

.github/copilot-instructions.md

@@ -1,4 +1,4 @@
-# GitHub Copilot Instructions for Helmpy
+# GitHub Copilot Instructions for helm-sdkpy
 
 ## Python Command Execution
 
@@ -57,7 +57,7 @@ This is a Python CLI application using:
 - `uv` for dependency management
 - `pytest` for testing
 - `just` for task automation
-- `Helmpy` as the main package
+- `helm-sdkpy` as the main package
 - `docusaurus` for documentation
 - `examples/` directory for usage patterns
 ## Testing Patterns

.github/workflows/ci.yml

@@ -1,4 +1,4 @@
-name: Helmpy Code Quality Checks
+name: helm-sdkpy Code Quality Checks
 on:
   workflow_call:
   pull_request:

.github/workflows/publish.yml

@@ -88,7 +88,7 @@ jobs:
         sudo snap install astral-uv --classic
         uv venv
         uv pip install dist/*.whl
-        uv run python3 -c "import helmpy; print('Package imported successfully')"
+        uv run python3 -c "import helm_sdkpy; print('Package imported successfully')"
 
   publish-pypi:
     name: Publish to PyPI

.github/workflows/update-docs.yml

@@ -4,7 +4,7 @@ on:
   push:
     branches: ["main"]
     paths:
-      - 'helmpy/**'
+      - 'helm_sdkpy/**'
       - 'scripts/update_docs_version.py'
       - 'pyproject.toml'
       - 'docusaurus/**'

DEVELOPMENT.md

@@ -1,24 +1,24 @@
 # Development Guide
 
-This document provides detailed information for developers working on helmpy.
+This document provides detailed information for developers working on helm-sdkpy.
 
 ## Architecture
 
-helmpy follows a three-layer architecture:
+helm-sdkpy follows a three-layer architecture:
 
 1. **Go Shim Layer** (`go/shim/main.go`)
    - Wraps Helm v4 Go API
    - Exposes C-compatible FFI functions
    - Handles memory management and error propagation
    - Thread-safe with mutex protection
 
-2. **Python FFI Layer** (`helmpy/_ffi.py`)
+2. **Python FFI Layer** (`helm_sdkpy/_ffi.py`)
    - Uses CFFI to interface with Go shared library
    - Handles library loading and discovery
    - Provides type conversion helpers
    - Manages error checking
 
-3. **Python API Layer** (`helmpy/actions.py`, `helmpy/chart.py`)
+3. **Python API Layer** (`helm_sdkpy/actions.py`, `helm_sdkpy/chart.py`)
    - Async-first Pythonic wrapper classes
    - Type hints for IDE support
    - Context manager support
@@ -38,8 +38,8 @@ helmpy follows a three-layer architecture:
 
 ```bash
 # Clone the repository
-git clone https://github.com/vantagecompute/helmpy.git
-cd helmpy
+git clone https://github.com/vantagecompute/helm-sdkpy.git
+cd helm-sdkpy
 
 # Install Python dependencies
 pip install -e ".[dev]"
@@ -88,15 +88,15 @@ This runs a multi-stage Docker build that:
 1. Sets up Go 1.22 build environment
 2. Downloads Helm v4 and all dependencies
 3. Compiles the Go shim to a shared library
-4. Extracts the library to `helmpy/_lib/linux-amd64/`
+4. Extracts the library to `helm_sdkpy/_lib/linux-amd64/`
 
 ### Local Build (Development)
 
 For faster iteration during development:
 
 ```bash
 cd go/shim
-go build -buildmode=c-shared -o ../../helmpy/_lib/linux-amd64/libhelmpy.so main.go
+go build -buildmode=c-shared -o ../../helm_sdkpy/_lib/linux-amd64/libhelm-sdkpy.so main.go
 ```
 
 Note: This requires Go 1.22+ and all dependencies to be available locally.
@@ -122,21 +122,21 @@ Tests are located in the `tests/` directory. Follow these guidelines:
 
 1. **Import from top-level package**:
    ```python
-   import helmpy
-   from helmpy import Configuration, Install
+   import helm-sdkpy
+   from helm-sdkpy import Configuration, Install
    ```
 
 2. **Use pytest fixtures** for common setup:
    ```python
    @pytest.fixture
    def config():
-       return helmpy.Configuration(namespace="test")
+       return helm-sdkpy.Configuration(namespace="test")
    ```
 
 2. **Test exception handling**:
    ```python
    async def test_install_error():
-       with pytest.raises(helmpy.InstallError):
+       with pytest.raises(helm-sdkpy.InstallError):
            # Code that should raise
            await install.run(...)
    ```
@@ -170,22 +170,22 @@ Follow standard Go conventions:
 
 To add support for a new Helm action:
 
-1. **Add FFI definition** in `helmpy/_ffi.py`:
+1. **Add FFI definition** in `helm_sdkpy/_ffi.py`:
    ```python
    ffi.cdef("""
-       int helmpy_new_action(helmpy_handle handle, const char *param, char **result);
+       int helm-sdkpy_new_action(helm-sdkpy_handle handle, const char *param, char **result);
    """)
    ```
 
 2. **Implement Go function** in `go/shim/main.go`:
    ```go
-   //export helmpy_new_action
-   func helmpy_new_action(handle C.helmpy_handle, param *C.char, result **C.char) C.int {
+   //export helm-sdkpy_new_action
+   func helm-sdkpy_new_action(handle C.helm-sdkpy_handle, param *C.char, result **C.char) C.int {
        // Implementation
    }
    ```
 
-3. **Create Python wrapper** in `helmpy/actions.py` or `helmpy/chart.py`:
+3. **Create Python wrapper** in `helm_sdkpy/actions.py` or `helm_sdkpy/chart.py`:
    ```python
    class NewAction:
        def __init__(self, config: Configuration):
@@ -212,8 +212,8 @@ To add support for a new Helm action:
 
    @pytest.mark.asyncio
    async def test_new_action():
-       config = helmpy.Configuration(namespace="test")
-       action = helmpy.NewAction(config)
+       config = helm-sdkpy.Configuration(namespace="test")
+       action = helm-sdkpy.NewAction(config)
        result = await action.run("param")
        assert result is not None
    ```
@@ -222,7 +222,7 @@ To add support for a new Helm action:
 
 1. Update version in:
    - `pyproject.toml`
-   - `helmpy/__init__.py`
+   - `helm_sdkpy/__init__.py`
    - `go/shim/main.go` (versionCString)
 
 2. Build and test:
@@ -252,7 +252,7 @@ If you get `HelmLibraryNotFound`:
 
 1. Check if library exists:
    ```bash
-   ls -lh helmpy/_lib/linux-amd64/libhelmpy.so
+   ls -lh helm_sdkpy/_lib/linux-amd64/libhelm-sdkpy.so
    ```
 
 2. Rebuild if missing:
@@ -262,7 +262,7 @@ If you get `HelmLibraryNotFound`:
 
 3. Check library dependencies:
    ```bash
-   ldd helmpy/_lib/linux-amd64/libhelmpy.so
+   ldd helm_sdkpy/_lib/linux-amd64/libhelm-sdkpy.so
    ```
 
 ### Import Errors
@@ -276,7 +276,7 @@ If Python can't find the module:
 
 2. Or set PYTHONPATH:
    ```bash
-   export PYTHONPATH=/path/to/helmpy:$PYTHONPATH
+   export PYTHONPATH=/path/to/helm-sdkpy:$PYTHONPATH
    ```
 
 ### Go Build Errors

IMPLEMENTATION_SUMMARY.md

@@ -1,8 +1,8 @@
-# helmpy Implementation Summary
+# helm-sdkpy Implementation Summary
 
 ## Project Overview
 
-**helmpy** is a complete Python wrapper for the Helm v4 Go API, providing full access to Helm's functionality from Python applications. Following the architecture pattern of dqlitepy, it creates a self-contained package with no system dependencies.
+**helm-sdkpy** is a complete Python wrapper for the Helm v4 Go API, providing full access to Helm's functionality from Python applications. Following the architecture pattern of dqlitepy, it creates a self-contained package with no system dependencies.
 
 ## Implementation Status: ✅ COMPLETE
 
@@ -20,7 +20,7 @@ All requirements from the problem statement have been fulfilled:
 └────────────────────────────────────────────────────────┘
                          ↓
 ┌────────────────────────────────────────────────────────┐
-│      helmpy Python Package (Async-First, Type-Safe)     │
+│      helm-sdkpy Python Package (Async-First, Type-Safe)     │
 │  ┌──────────────────────────────────────────────────┐  │
 │  │ actions.py: async Install, Upgrade, Uninstall    │  │
 │  │ chart.py: async Pull, Show, Lint, Package, Test │  │
@@ -81,7 +81,7 @@ All operations use Python's `async/await` syntax for non-blocking execution and
 ## Project Structure
 
 ```
-helmpy/
+helm_sdkpy/
 ├── .gitignore                    # Build artifacts exclusion
 ├── .python-version               # Python 3.12 specification
 ├── LICENSE                       # Apache 2.0 license
@@ -97,7 +97,7 @@ helmpy/
 │   └── shim/
 │       └── main.go               # C FFI implementation (700+ lines)
 │
-├── helmpy/                       # Python package
+├── helm_sdkpy/                       # Python package
 │   ├── __init__.py               # Package exports
 │   ├── _ffi.py                   # CFFI bindings (220 lines)
 │   ├── exceptions.py             # 10 exception types (70 lines)
@@ -186,14 +186,14 @@ just fmt         # Format code
 
 ```python
 import asyncio
-import helmpy
+import helm-sdkpy
 
 async def main():
     # Create configuration
-    config = helmpy.Configuration(namespace="default")
+    config = helm-sdkpy.Configuration(namespace="default")
 
     # Install chart (async)
-    install = helmpy.Install(config)
+    install = helm-sdkpy.Install(config)
     result = await install.run(
         release_name="my-nginx",
         chart_path="./nginx-chart",
@@ -203,17 +203,17 @@ async def main():
     )
 
     # List releases (async)
-    releases = await helmpy.List(config).run(all=True)
+    releases = await helm-sdkpy.List(config).run(all=True)
 
     # Upgrade (async)
-    upgrade = helmpy.Upgrade(config)
+    upgrade = helm-sdkpy.Upgrade(config)
     await upgrade.run("my-nginx", "./nginx-chart", {"replicaCount": 5})
 
     # Rollback (async)
-    await helmpy.Rollback(config).run("my-nginx", revision=1)
+    await helm-sdkpy.Rollback(config).run("my-nginx", revision=1)
 
     # Uninstall (async)
-    await helmpy.Uninstall(config).run("my-nginx", wait=True)
+    await helm-sdkpy.Uninstall(config).run("my-nginx", wait=True)
 
 asyncio.run(main())
 ```
@@ -222,11 +222,11 @@ asyncio.run(main())
 
 ```python
 import asyncio
-import helmpy
+import helm-sdkpy
 
 async def deploy_multiple():
-    config = helmpy.Configuration(namespace="default")
-    install = helmpy.Install(config)
+    config = helm-sdkpy.Configuration(namespace="default")
+    install = helm-sdkpy.Install(config)
 
     # Install multiple charts concurrently
     results = await asyncio.gather(
@@ -325,9 +325,9 @@ just build-lib
 pip install .
 
 # Or use directly
-python -c "import helmpy; print(helmpy.__version__)"
+python -c "import helm-sdkpy; print(helm-sdkpy.__version__)"
 ```
 
 ## Conclusion
 
-The helmpy implementation is **complete and production-ready**, providing a comprehensive, type-safe, async-first, and self-contained Python wrapper for the entire Helm v4 Go API. All 19 actions use Python's async/await syntax for non-blocking execution and support concurrent operations with asyncio.gather(), making it ideal for modern Python applications, web frameworks, and event-driven architectures. The implementation follows the exact pattern demonstrated in dqlitepy.
+The helm-sdkpy implementation is **complete and production-ready**, providing a comprehensive, type-safe, async-first, and self-contained Python wrapper for the entire Helm v4 Go API. All 19 actions use Python's async/await syntax for non-blocking execution and support concurrent operations with asyncio.gather(), making it ideal for modern Python applications, web frameworks, and event-driven architectures. The implementation follows the exact pattern demonstrated in dqlitepy.