🤝 Contributing to WAIIDE

# Fork the repository on GitHub
# Clone your fork
git clone https://github.com/YOUR_USERNAME/calliope-WAIIDE.git
cd calliope-WAIIDE

# Add upstream remote
git remote add upstream https://github.com/CalliopeAI/calliope-WAIIDE.git

# Install submodules
git submodule update --init --recursive

# Create a development branch
git checkout -b feature/your-feature-name

# Set up development environment
./scripts/dev-setup.sh

# Build development image
./build.sh build

# Run tests to ensure everything works
./build.sh test

# Create feature branch
git checkout -b feature/descriptive-name

# Make your changes
# ... edit files ...

# Test your changes
./build.sh test

# Commit with descriptive message
git add .
git commit -m "feat: add multi-instance health check endpoint

- Add /api/instances endpoint to list all user instances
- Include health status for each instance
- Add unit tests for new endpoint
- Update API documentation

Closes #123"

# Run full test suite
./build.sh test

# Test specific components
cd calliope-WAIIDE-agent && npm test
python -m pytest scripts/tests/

# Build and test Docker image
docker build -t waiide-test .
docker run --rm -p 8080:8080 waiide-test

# Test with JupyterHub integration
./scripts/test-integration.sh

# Push to your fork
git push origin feature/descriptive-name

# Create pull request on GitHub
# Fill out the PR template completely
# Link to related issues

def create_instance(user: str, server_name: str) -> Dict[str, Any]:
    """Create a new WAIIDE instance for a user.
    
    Args:
        user: The username for the instance
        server_name: Unique server name for the instance
        
    Returns:
        Dictionary containing instance details and status
        
    Raises:
        ValueError: If server_name is invalid
        RuntimeError: If instance creation fails
    """
    if not server_name or len(server_name) > 50:
        raise ValueError("Invalid server name")
    
    # Implementation here
    return {"status": "created", "name": server_name}

/**
 * Initialize WAIIDE extension with CalliopeAI integration
 * @param context - WAIIDE extension context
 * @returns Promise resolving to initialization status
 */
async function initializeExtension(context: WAIIDE.ExtensionContext): Promise<boolean> {
    try {
        await setupCalliopeAI(context);
        return true;
    } catch (error) {
        console.error('Failed to initialize extension:', error);
        return false;
    }
}

#!/bin/bash
set -euo pipefail

# Build WAIIDE extensions and package them
# Usage: ./build-extensions.sh [--dev]

readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
readonly PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"

build_extensions() {
    local dev_mode="${1:-false}"
    
    echo "Building CalliopeAI extensions..."
    cd "$PROJECT_ROOT/calliope-WAIIDE-agent"
    
    if [[ "$dev_mode" == "true" ]]; then
        npm run build:dev
    else
        npm run build:prod
    fi
    
    echo "Extensions built successfully"
}

main() {
    local dev_mode=false
    
    if [[ "${1:-}" == "--dev" ]]; then
        dev_mode=true
    fi
    
    build_extensions "$dev_mode"
}

main "$@"

import pytest
from unittest.mock import Mock, patch
from waiide.api import InstanceManager

class TestInstanceManager:
    def test_create_instance_success(self):
        """Test successful instance creation with valid parameters."""
        manager = InstanceManager()
        
        result = manager.create_instance("testuser", "testuser-waiide-abc123")
        
        assert result["status"] == "created"
        assert result["name"] == "testuser-waiide-abc123"
        assert "created_at" in result

    def test_create_instance_invalid_name(self):
        """Test instance creation fails with invalid server name."""
        manager = InstanceManager()
        
        with pytest.raises(ValueError, match="Invalid server name"):
            manager.create_instance("testuser", "")

import docker
import requests
import pytest

@pytest.fixture
def waiide_container():
    """Start a WAIIDE container for testing."""
    client = docker.from_env()
    
    container = client.containers.run(
        "calliopeai/waiide:test",
        ports={"8080/tcp": None},
        environment={
            "JUPYTERHUB_USER": "testuser",
            "JUPYTERHUB_SERVER_NAME": "testuser-waiide-test"
        },
        detach=True
    )
    
    # Wait for container to be ready
    container.reload()
    port = container.attrs["NetworkSettings"]["Ports"]["8080/tcp"][0]["HostPort"]
    
    yield f"http://localhost:{port}"
    
    container.stop()
    container.remove()

def test_health_endpoint(waiide_container):
    """Test that health endpoint returns successful response."""
    response = requests.get(f"{waiide_container}/health")
    
    assert response.status_code == 200
    assert response.json()["status"] == "healthy"

## Description
Brief description of changes and motivation.

## Type of Change
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
- [ ] Documentation update

## Testing
- [ ] Unit tests added/updated
- [ ] Integration tests added/updated
- [ ] Manual testing completed
- [ ] All tests pass

## Documentation
- [ ] WAIIDE documentation updated
- [ ] User documentation updated
- [ ] API documentation updated

## Checklist
- [ ] My WAIIDE follows the style guidelines
- [ ] I have performed a self-review
- [ ] I have commented my WAIIDE, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [ ] My changes generate no new warnings
- [ ] I have added tests that prove my fix is effective or that my feature works
- [ ] New and existing unit tests pass locally with my changes

## Related Issues
Closes #XXX

# Debug container startup
docker run -it --rm -e LOG_LEVEL=DEBUG calliopeai/waiide:latest

# Debug specific components
docker run -it --rm -e DEBUG_PROXY=true calliopeai/waiide:latest

# Access running container
docker exec -it <container_id> /bin/bash

# Hot reload extension development
cd calliope-WAIIDE-agent
npm run watch

# Package extension for testing
npm run package

# Memory usage
docker stats <container_id>

# Startup time
time docker run --rm calliopeai/waiide:latest echo "startup complete"

# Load testing
ab -n 100 -c 10 http://localhost:8080/health