wizelit-sdk 0.1.30__py3-none-any.whl → 0.1.32__py3-none-any.whl

wizelit_sdk/__init__.py

@@ -6,6 +6,42 @@ from wizelit_sdk.agent_wrapper.job import Job
 from wizelit_sdk.agent_wrapper.streaming import LogStreamer
 from wizelit_sdk.models.base import BaseModel
 from wizelit_sdk.models.job import JobModel, JobLogModel, JobStatus
+from wizelit_sdk.exceptions import (
+    WizelitSDKException,
+    AgentInitializationError,
+    SignatureValidationError,
+    JobExecutionError,
+    JobNotFoundError,
+    ToolRegistrationError,
+    DatabaseManagerError,
+    StreamingError,
+    ContextVariableError,
+    InvalidConfigError,
+    TransportError,
+    TimeoutError,
+)
 
-__all__ = ["WizelitAgent", "DatabaseManager", "Job", "LogStreamer", "BaseModel", "JobModel", "JobLogModel", "JobStatus"]
+__all__ = [
+    "WizelitAgent",
+    "DatabaseManager",
+    "Job",
+    "LogStreamer",
+    "BaseModel",
+    "JobModel",
+    "JobLogModel",
+    "JobStatus",
+    # Exceptions
+    "WizelitSDKException",
+    "AgentInitializationError",
+    "SignatureValidationError",
+    "JobExecutionError",
+    "JobNotFoundError",
+    "ToolRegistrationError",
+    "DatabaseManagerError",
+    "StreamingError",
+    "ContextVariableError",
+    "InvalidConfigError",
+    "TransportError",
+    "TimeoutError",
+]
 

wizelit_sdk/agent_wrapper/agent_wrapper.py

@@ -13,6 +13,9 @@ from wizelit_sdk.agent_wrapper.signature_validation import (
     bind_and_validate_arguments,
     ensure_type_hints,
 )
+from wizelit_sdk.exceptions import (
+    StreamingError,
+)
 
 # Local Transport literal to avoid import issues when fastmcp.types is unavailable
 Transport = Literal["stdio", "http", "sse", "streamable-http"]
@@ -92,7 +95,10 @@ class WizelitAgent:
             except ImportError:
                 print("Warning: redis package not installed. Log streaming disabled.")
             except Exception as e:
-                print(f"Warning: Failed to initialize log streamer: {e}")
+                raise StreamingError(
+                    "Failed to initialize log streaming",
+                    f"Could not connect to Redis at {redis_url}: {str(e)}"
+                )
 
         print(
             f"WizelitAgent initialized with name: {name}, transport: {transport}, host: {host}, port: {port}"

wizelit_sdk/cli.py

@@ -0,0 +1,337 @@
+"""Command-line utilities for Wizelit SDK."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from textwrap import dedent
+
+import click
+
+
+TRANSPORT_CHOICES = ["streamable-http", "sse", "stdio", "http"]
+
+
+def _slugify(value: str) -> str:
+    value = value.strip().lower()
+    value = re.sub(r"[^a-z0-9]+", "-", value)
+    value = value.strip("-")
+    if not value:
+        raise click.ClickException("Agent name must contain letters or numbers.")
+    return value
+
+
+def _write_file(path: Path, content: str, force: bool) -> None:
+    if path.exists() and not force:
+        raise click.ClickException(
+            f"File already exists: {path}. Use --force to overwrite."
+        )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+
+
+def _render_main_py(
+    agent_name: str, transport: str, host: str, port: int
+) -> str:
+    return dedent(
+        f'''"""Wizelit Agent Scaffold
+        Generated by wizelit-agent CLI.
+        """
+
+        from wizelit_sdk.agent_wrapper import WizelitAgent
+
+        mcp = WizelitAgent(
+            "{agent_name}",
+            transport="{transport}",
+            host="{host}",
+            port={port},
+        )
+
+
+        @mcp.ingest(
+            is_long_running=False,
+            description="Describe your tool here.",
+            response_handling={{"mode": "json"}},
+        )
+        def example_tool(text: str) -> dict:
+            """Example tool."""
+            return {{"echo": text}}
+
+
+        if __name__ == "__main__":
+            mcp.run()
+        '''
+    ).lstrip()
+
+
+def _render_readme(agent_name: str) -> str:
+    return dedent(
+        f"""
+        # {agent_name}
+
+        Generated Wizelit agent scaffold.
+
+        ## Run
+
+        ```bash
+        python main.py
+        ```
+        """
+    ).lstrip()
+
+
+def _render_env_example() -> str:
+    return dedent(
+        """
+        # Example environment variables
+        REDIS_URL=redis://localhost:6379
+        ENABLE_LOG_STREAMING=true
+
+        # AWS (if using Bedrock)
+        AWS_ACCESS_KEY_ID=
+        AWS_SECRET_ACCESS_KEY=
+        AWS_REGION=us-east-1
+        """
+    ).lstrip()
+
+
+def _render_requirements(template: str) -> str:
+    # Always include the SDK and click for CLI-based scaffolds
+    base = ["wizelit-sdk", "click>=8.1.0"]
+    if template == "fast":
+        extras = []
+    elif template == "slow":
+        extras = ["redis>=4.5.0"]
+    else:  # hybrid
+        extras = ["redis>=4.5.0"]
+    return "\n".join(base + extras) + "\n"
+
+
+def _render_main_for_template(agent_name: str, template: str) -> str:
+    # Fast agent: synchronous/simple
+    if template == "fast":
+        return dedent(
+            f'''
+            """Fast Wizelit Agent
+            Generated by wizelit CLI
+            """
+
+            from wizelit_sdk.agent_wrapper import WizelitAgent
+
+            mcp = WizelitAgent(
+                "{agent_name}",
+                transport="streamable-http",
+            )
+
+
+            @mcp.ingest(is_long_running=False, description="Fast sync tool")
+            def analyze(text: str) -> dict:
+                """A fast synchronous tool example."""
+                return {{"echo": text}}
+
+
+            if __name__ == "__main__":
+                mcp.run()
+            '''
+        ).lstrip()
+
+    # Slow agent: long-running async example
+    if template == "slow":
+        return dedent(
+            f'''
+            """Slow Wizelit Agent (long-running)
+            Generated by wizelit CLI
+            """
+
+            import asyncio
+            from wizelit_sdk.agent_wrapper import WizelitAgent, Job
+
+            mcp = WizelitAgent(
+                "{agent_name}",
+                transport="streamable-http",
+                enable_streaming=True,
+            )
+
+
+            @mcp.ingest(is_long_running=True, description="Long-running refactor")
+            async def long_task(code: str, job: Job) -> dict:
+                job.logger.info("Starting long-running task")
+                # Simulate work and progress
+                for i in range(3):
+                    await asyncio.sleep(1)
+                    job.logger.info(f"Progress: {{i+1}}/3")
+                return {{"result": "done"}}
+
+
+            if __name__ == "__main__":
+                mcp.run()
+            '''
+        ).lstrip()
+
+    # Hybrid: both examples present
+    return dedent(
+        f'''
+        """Hybrid Wizelit Agent
+        Generated by wizelit CLI
+        """
+
+        import asyncio
+        from wizelit_sdk.agent_wrapper import WizelitAgent, Job
+
+        mcp = WizelitAgent(
+            "{agent_name}",
+            transport="streamable-http",
+            enable_streaming=True,
+        )
+
+
+        @mcp.ingest(is_long_running=False, description="Fast helper")
+        def quick(text: str) -> dict:
+            return {{"echo": text}}
+
+
+        @mcp.ingest(is_long_running=True, description="Slow worker")
+        async def worker(payload: str, job: Job) -> dict:
+            job.logger.info("Hybrid worker starting")
+            await asyncio.sleep(1)
+            return {{"status": "ok"}}
+
+
+        if __name__ == "__main__":
+            mcp.run()
+        '''
+    ).lstrip()
+
+
+@click.group()
+def cli() -> None:
+    """Wizelit SDK command-line tools."""
+
+
+@cli.command("scaffold")
+@click.argument("name")
+@click.option(
+    "--output-dir",
+    "-o",
+    type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
+    default=Path.cwd(),
+    show_default="current directory",
+)
+@click.option(
+    "--transport",
+    type=click.Choice(TRANSPORT_CHOICES),
+    default="streamable-http",
+    show_default=True,
+)
+@click.option("--host", default="0.0.0.0", show_default=True)
+@click.option("--port", default=8080, show_default=True, type=int)
+@click.option("--force", is_flag=True, help="Overwrite existing files.")
+def scaffold(
+    name: str,
+    output_dir: Path,
+    transport: str,
+    host: str,
+    port: int,
+    force: bool,
+) -> None:
+    """Scaffold a new Wizelit agent project."""
+    slug = _slugify(name)
+    project_dir = output_dir / slug
+
+    project_dir.mkdir(parents=True, exist_ok=True)
+
+    _write_file(project_dir / "main.py", _render_main_py(name, transport, host, port), force)
+    _write_file(project_dir / "README.md", _render_readme(name), force)
+    # Ensure generated scaffold includes click as a runtime dependency
+    _write_file(
+        project_dir / "requirements.txt",
+        "wizelit-sdk\nclick>=8.1.0\n",
+        force,
+    )
+
+    click.echo(f"✅ Scaffold created at: {project_dir}")
+    click.echo("Next steps:")
+    click.echo("  1) Install dependencies: pip install -r requirements.txt")
+    click.echo("  2) Run the agent: python main.py")
+
+
+@cli.command("init")
+@click.argument("name")
+@click.option("--template", type=click.Choice(["fast", "slow", "hybrid"]), default="fast")
+@click.option(
+    "--output-dir",
+    "-o",
+    type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
+    default=Path.cwd(),
+    show_default="current directory",
+)
+@click.option("--force", is_flag=True, help="Overwrite existing files.")
+def init(name: str, template: str, output_dir: Path, force: bool) -> None:
+    """Initialize a new Wizelit agent project using a template."""
+    slug = _slugify(name)
+    project_dir = output_dir / slug
+    project_dir.mkdir(parents=True, exist_ok=True)
+
+    # Write main.py for the selected template
+    _write_file(project_dir / "main.py", _render_main_for_template(name, template), force)
+    _write_file(project_dir / "README.md", _render_readme(name), force)
+    _write_file(project_dir / "requirements.txt", _render_requirements(template), force)
+    _write_file(project_dir / ".env.example", _render_env_example(), force)
+
+    click.echo(f"✅ Project initialized at: {project_dir}")
+    click.echo("Next steps:")
+    click.echo("  1) Install dependencies: pip install -r requirements.txt")
+    click.echo("  2) Run the agent: python main.py")
+
+
+@cli.command("validate")
+@click.argument("path", type=click.Path(file_okay=True, dir_okay=True, path_type=Path), default=Path.cwd())
+def validate(path: Path) -> None:
+    """Validate a Wizelit agent project structure."""
+    if path.is_file():
+        project_dir = path.parent
+    else:
+        project_dir = path
+
+    required = ["main.py", "requirements.txt", "README.md"]
+    missing = [p for p in required if not (project_dir / p).exists()]
+    if missing:
+        click.echo(f"❌ Missing files: {missing}")
+        raise click.Abort()
+    click.echo("✅ Project looks valid")
+
+
+@cli.command("list-tools")
+@click.argument("path", type=click.Path(file_okay=True, dir_okay=True, path_type=Path), default=Path.cwd())
+def list_tools(path: Path) -> None:
+    """List tools (functions decorated with @mcp.ingest) in a project."""
+    if path.is_file():
+        project_dir = path.parent
+    else:
+        project_dir = path
+
+    py_files = list(project_dir.glob("*.py"))
+    tools = []
+    for f in py_files:
+        text = f.read_text(encoding="utf-8")
+        if "@mcp.ingest" in text:
+            # naive extraction: look for def <name>( after decorator
+            for line in text.splitlines():
+                if line.strip().startswith("def "):
+                    name = line.strip().split()[1].split("(")[0]
+                    tools.append((f.name, name))
+
+    if not tools:
+        click.echo("No tools found (no @mcp.ingest decorators detected).")
+        return
+
+    for file, name in tools:
+        click.echo(f"- {name} (in {file})")
+
+
+def main() -> None:
+    cli()
+
+
+if __name__ == "__main__":
+    main()

wizelit_sdk/exceptions.py

@@ -0,0 +1,206 @@
+"""
+Custom exceptions for Wizelit SDK with helpful error messages and suggestions.
+"""
+
+
+class WizelitSDKException(Exception):
+    """Base exception class for all Wizelit SDK errors."""
+
+    def __init__(self, message: str, suggestion: str = ""):
+        self.message = message
+        self.suggestion = suggestion
+        full_message = message
+        if suggestion:
+            full_message = f"{message}\n💡 Suggestion: {suggestion}"
+        super().__init__(full_message)
+
+
+class AgentInitializationError(WizelitSDKException):
+    """Raised when WizelitAgent cannot be initialized."""
+
+    def __init__(self, reason: str = "", original_error: str = ""):
+        message = "Failed to initialize WizelitAgent"
+        if reason:
+            message += f": {reason}"
+        if original_error:
+            message += f" ({original_error})"
+        suggestion = (
+            "1. Verify all required dependencies are installed\n"
+            "2. Check that the name parameter is provided\n"
+            "3. Verify the transport mode is valid (sse, http, streamable-http, stdio)\n"
+            "4. Check that host and port are available and not in use\n"
+            "5. Review the initialization code for configuration errors"
+        )
+        super().__init__(message, suggestion)
+
+
+class SignatureValidationError(WizelitSDKException):
+    """Raised when a function signature doesn't meet requirements."""
+
+    def __init__(self, function_name: str, reason: str = ""):
+        message = f"Signature validation failed for function '{function_name}'"
+        if reason:
+            message += f": {reason}"
+        suggestion = (
+            f"1. Ensure all parameters of '{function_name}' have type hints\n"
+            f"2. Verify parameter names match between definition and usage\n"
+            f"3. Check that the function signature is compatible with the ingest decorator\n"
+            f"4. Ensure complex types are properly imported and defined\n"
+            f"5. Review the decorator parameters for compatibility"
+        )
+        super().__init__(message, suggestion)
+
+
+class JobExecutionError(WizelitSDKException):
+    """Raised when a job fails during execution."""
+
+    def __init__(self, job_id: str, reason: str = "", original_error: str = ""):
+        message = f"Job execution failed for job_id '{job_id}'"
+        if reason:
+            message += f": {reason}"
+        if original_error:
+            message += f" ({original_error})"
+        suggestion = (
+            "1. Check the job logs for detailed error information\n"
+            "2. Verify job inputs are valid and complete\n"
+            "3. Check if the underlying tool/function has dependencies\n"
+            "4. Try running the job again with the same inputs\n"
+            "5. Check application logs and database logs for more context"
+        )
+        super().__init__(message, suggestion)
+
+
+class JobNotFoundError(WizelitSDKException):
+    """Raised when a job cannot be found."""
+
+    def __init__(self, job_id: str):
+        message = f"Job not found: {job_id}"
+        suggestion = (
+            "1. Verify the job_id is correct and complete\n"
+            "2. Check if the job has expired or been deleted\n"
+            "3. Verify the job was created in the current session\n"
+            "4. Check the database for job records\n"
+            "5. Review job retention policies"
+        )
+        super().__init__(message, suggestion)
+
+
+class ToolRegistrationError(WizelitSDKException):
+    """Raised when a tool cannot be registered with the MCP server."""
+
+    def __init__(self, tool_name: str, reason: str = ""):
+        message = f"Failed to register tool '{tool_name}' with MCP server"
+        if reason:
+            message += f": {reason}"
+        suggestion = (
+            f"1. Verify '{tool_name}' function is properly decorated with @ingest\n"
+            f"2. Check that function name is unique across all registered tools\n"
+            f"3. Verify function signature is valid with type hints\n"
+            f"4. Check for duplicate tool registrations\n"
+            f"5. Ensure the FastMCP server is properly initialized"
+        )
+        super().__init__(message, suggestion)
+
+
+class DatabaseManagerError(WizelitSDKException):
+    """Raised when database operations fail."""
+
+    def __init__(self, operation: str, reason: str = ""):
+        message = f"Database operation failed: {operation}"
+        if reason:
+            message += f" ({reason})"
+        suggestion = (
+            "1. Verify the database is running and accessible\n"
+            "2. Check database connection parameters (host, port, credentials)\n"
+            "3. Verify the database has sufficient disk space\n"
+            "4. Check if the database tables are properly initialized\n"
+            "5. Review database logs for detailed error information"
+        )
+        super().__init__(message, suggestion)
+
+
+class StreamingError(WizelitSDKException):
+    """Raised when log streaming fails."""
+
+    def __init__(self, reason: str = "", original_error: str = ""):
+        message = "Error in log streaming"
+        if reason:
+            message += f": {reason}"
+        if original_error:
+            message += f" ({original_error})"
+        suggestion = (
+            "1. Verify Redis is running and accessible\n"
+            "2. Check REDIS_URL environment variable is set correctly\n"
+            "3. Verify network connectivity to Redis\n"
+            "4. Check Redis logs for connection errors\n"
+            "5. Log streaming is optional - the SDK will continue without it"
+        )
+        super().__init__(message, suggestion)
+
+
+class ContextVariableError(WizelitSDKException):
+    """Raised when context variable operations fail."""
+
+    def __init__(self, variable_name: str, reason: str = ""):
+        message = f"Error accessing context variable '{variable_name}'"
+        if reason:
+            message += f": {reason}"
+        suggestion = (
+            f"1. Ensure '{variable_name}' is set before accessing\n"
+            f"2. Verify the context is active in the current async task\n"
+            f"3. Check if using the decorator or dependency injection correctly\n"
+            f"4. Ensure context propagation across async calls\n"
+            f"5. Review context variable usage documentation"
+        )
+        super().__init__(message, suggestion)
+
+
+class InvalidConfigError(WizelitSDKException):
+    """Raised when configuration is invalid or missing."""
+
+    def __init__(self, config_key: str, expected_type: str = "", reason: str = ""):
+        message = f"Invalid configuration for '{config_key}'"
+        if expected_type:
+            message += f" (expected: {expected_type})"
+        if reason:
+            message += f": {reason}"
+        suggestion = (
+            f"1. Verify {config_key} is set in environment variables\n"
+            f"2. Check the value format and type\n"
+            f"3. Review configuration documentation for valid values\n"
+            f"4. Check .env file or deployment configuration\n"
+            f"5. Restart the application after fixing configuration"
+        )
+        super().__init__(message, suggestion)
+
+
+class TransportError(WizelitSDKException):
+    """Raised when transport/communication errors occur."""
+
+    def __init__(self, transport_type: str, reason: str = ""):
+        message = f"Transport error with '{transport_type}'"
+        if reason:
+            message += f": {reason}"
+        suggestion = (
+            f"1. Verify the {transport_type} transport is properly configured\n"
+            f"2. Check network connectivity and firewall rules\n"
+            f"3. Verify server ports are open and accessible\n"
+            f"4. Check if there are proxy or routing issues\n"
+            f"5. Review transport-specific logs for detailed information"
+        )
+        super().__init__(message, suggestion)
+
+
+class TimeoutError(WizelitSDKException):
+    """Raised when an operation exceeds the timeout limit."""
+
+    def __init__(self, operation: str, timeout_seconds: float):
+        message = f"Operation '{operation}' exceeded timeout of {timeout_seconds} seconds"
+        suggestion = (
+            f"1. The {operation} took too long to complete\n"
+            f"2. Check if there are resource constraints (CPU, memory)\n"
+            f"3. Simplify the job inputs or query\n"
+            f"4. Check application and system logs for bottlenecks\n"
+            f"5. Consider increasing timeout if the operation is expected to be slow"
+        )
+        super().__init__(message, suggestion)

wizelit_sdk-0.1.32.dist-info/METADATA

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: wizelit-sdk
+Version: 0.1.32
+Summary: Wizelit Agent Wrapper - Internal utility package
+Author-email: Your Name <your.email@company.com>
+Requires-Python: >=3.10
+Requires-Dist: asyncpg>=0.26.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: fastmcp>=0.1.0
+Requires-Dist: redis>=4.5.0
+Requires-Dist: sqlalchemy>=1.4
+Requires-Dist: typeguard>=4.3.0
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: dev
+Requires-Dist: black>=22.0.0; extra == 'dev'
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: streaming
+Requires-Dist: redis>=4.5.0; extra == 'streaming'
+Description-Content-Type: text/markdown
+
+# wizelit-sdk
+
+Internal utility package for Wizelit Agent operations.
+
+> **New to Wizelit?** Start with the [**Quick Start Guide**](./QUICKSTART.md) to build your first agent in under 30 minutes!
+
+## Installation
+
+### Install from PyPI
+
+```bash
+uv pip install wizelit-sdk
+```
+
+### Add to pyproject.toml
+
+```toml
+[project]
+dependencies = [
+    "wizelit-sdk"
+]
+```
+
+## Quickstart
+
+1. Install the package (see above).
+2. Configure environment variables (see Configuration).
+3. Import and use the SDK from your app.
+
+### CLI
+
+The package also installs a small command-line tool named `wizelit-sdk` which helps scaffold and manage agent projects.
+
+Install and run the CLI:
+
+```bash
+# Install package (global or in virtualenv)
+pip install wizelit-sdk
+
+# Create a new project using a template (fast|slow|hybrid)
+wizelit-sdk init "My Agent" --template hybrid
+
+# Alternative (without wrapper):
+python -m wizelit_sdk.cli init "My Agent" --template hybrid
+```
+
+Useful commands:
+
+- `wizelit-sdk init <name> [--template fast|slow|hybrid]` — scaffold a new agent project
+- `wizelit-sdk scaffold <name>` — basic scaffold (older command)
+- `wizelit-sdk validate [path]` — validate project structure
+- `wizelit-sdk list-tools [path]` — list functions decorated with `@mcp.ingest`
+
+If you are developing locally, install editable and use the wrapper from your virtualenv:
+
+```bash
+# from repo root
+pip install -e .
+source .venv/bin/activate
+wizelit-sdk init "My Agent"
+```
+
+## Usage
+
+```python
+from wizelit_agent_wrapper import your_module
+
+# Use the wrapper
+result = your_module.function()
+```
+
+## SDK Guide
+
+### Basic import patterns
+
+```python
+from wizelit_sdk import database, exceptions
+from wizelit_sdk.agent_wrapper import agent_wrapper
+```
+
+### Initialize and call
+
+```python
+# Example: create a wrapper and call a method
+wrapper = agent_wrapper.WizelitAgentWrapper()
+result = wrapper.run()
+```
+
+### Error handling
+
+```python
+from wizelit_sdk.exceptions import WizelitError
+
+try:
+    wrapper.run()
+except WizelitError as exc:
+    # handle SDK-specific errors
+    print(exc)
+```
+
+## Configuration
+
+The SDK reads database configuration from the hosting application's environment. Provide these variables in the consuming project (e.g., via your app's .env or deployment secrets):
+
+- POSTGRES_USER
+- POSTGRES_PASSWORD
+- POSTGRES_HOST
+- POSTGRES_PORT
+- POSTGRES_DB
+
+You can also supply a full connection string via `DATABASE_URL` (overrides the individual fields). If using streaming/logging with Redis, set `REDIS_HOST`, `REDIS_PORT`, and optionally `REDIS_PASSWORD`.
+
+## Development
+
+### Setup Development Environment
+
+```bash
+# Clone repository
+git clone https://github.com/your-org/wizelit-sdk.git
+cd wizelit-sdk
+
+# Set up environment
+make setup
+
+# Activate virtual environment
+source .venv/bin/activate  # Windows: .venv\Scripts\activate
+
+# Install in development mode
+make install-dev
+```
+
+### Available Make Commands
+
+```bash
+make setup                  # Set up development environment
+make install                # Install package (production mode)
+make install-dev            # Install in development mode
+make test                   # Run tests
+make lint                   # Run code linting
+make format                 # Format code with black
+make check                  # Run tests and linting
+make clean                  # Clean build artifacts
+make build                  # Build package
+make release x.x.x          # Create new release (updates version, tags, pushes)
+make tag VERSION=x.x.x      # Create and push git tag
+make push                   # Push code and tags to remote
+make publish                # Publish package (run checks, build, push to remote)
+make publish-pypi           # Publish package to public PyPI
+make publish-artifactory    # Publish package to private Artifactory/PyPI
+make version                # Show current version
+make versions               # List all available versions
+```
+
+### Deploy to PyPI
+
+Use the built-in Makefile target (recommended):
+
+```bash
+make publish-pypi
+```
+
+This target will:
+
+1. Verify the git working tree is clean.
+2. Run tests and linting (`make check`).
+3. Build the package (`make build`).
+4. Upload the artifacts in `dist/` to PyPI via `twine`.
+
+Optional release/tag flow (before publishing):
+
+```bash
+# Interactive release flow (updates version, tags, pushes)
+make release x.x.x
+
+# Or tag a specific version
+make tag VERSION=x.x.x
+```
+
+Notes:
+
+- Ensure your PyPI credentials are configured locally (e.g., via $HOME/.pypirc or your preferred environment variables).
+- The package version must be unique on PyPI; if a version already exists, bump it and rebuild.
+
+## Contributing
+
+1. Create a feature branch
+2. Make your changes
+3. Run tests and linting: `make check`
+4. Commit your changes
+5. Push and create a pull request
+
+## Versioning
+
+We use [Semantic Versioning](https://semver.org/):
+
+- **MAJOR** version for incompatible API changes
+- **MINOR** version for new functionality (backward compatible)
+- **PATCH** version for bug fixes
+
+See [CHANGELOG.md](CHANGELOG.md) for version history.

{wizelit_sdk-0.1.30.dist-info → wizelit_sdk-0.1.32.dist-info}/RECORD

@@ -1,13 +1,16 @@
-wizelit_sdk/__init__.py,sha256=76Dt-WxNbEJwOCPqu2P9AooVSQoGmc8-CH1fxIWJ5Lo,471
+wizelit_sdk/__init__.py,sha256=GRV3STJaNUg2KelKmvU60nhpYMdQ5lX0_FQyV_e5g1I,1168
+wizelit_sdk/cli.py,sha256=9leN1OHMj9IszbEtmldJDd09epg5KCji6RiQ6xjzraI,9541
 wizelit_sdk/database.py,sha256=HzvMY-KZQBkGs-Ey_wKAIPOJEb5BqGjEi98Tip7CQBo,4830
+wizelit_sdk/exceptions.py,sha256=KHkexTbD5t05nD-t9RnrJIFcqOsATBOUX9y5uHVfQeE,8557
 wizelit_sdk/agent_wrapper/__init__.py,sha256=srVcHZfvpf3q8m2nzIST6Ofl2V8Vv5GRtcNXudOLiD8,333
-wizelit_sdk/agent_wrapper/agent_wrapper.py,sha256=qkskmRRjhIooXVeyZHbH5q1OIp30zw29bBRUoqTPYLE,23476
+wizelit_sdk/agent_wrapper/agent_wrapper.py,sha256=2IE1RXTpwzJJMnpEgetU8OCkR7txG_NMqJ-1W-rv9j0,23650
 wizelit_sdk/agent_wrapper/job.py,sha256=jW2Cl7QvSgZDUqWqZSND-V1XphGdISJuh9ViHgCn7iU,13770
 wizelit_sdk/agent_wrapper/signature_validation.py,sha256=Njplwofw36jXoWgBooaZCbwhkf72pR-UoRQ3Q6-biro,3729
 wizelit_sdk/agent_wrapper/streaming.py,sha256=l7SbvPuQYMdGO38t1upyI5wTVdd5eB-2BSwU-BQSlvc,6673
 wizelit_sdk/models/__init__.py,sha256=UB7nfHoE6hGcjfzy7w8AmuKVmYrTg9wIgGjG8GWziJ0,143
 wizelit_sdk/models/base.py,sha256=11XyxLUG0VjdiNxe4zmzGDUjKEOsjSvUjA8yaQgfCa0,758
 wizelit_sdk/models/job.py,sha256=HD8ohVqzakC8J7VAwmh8UCi_BLLiqx85TbR0FjO2rlg,2494
-wizelit_sdk-0.1.30.dist-info/METADATA,sha256=zCb8i8TbnbAVCtHzcBxhgvQOlNIyNehCKQUWVCYpeqA,3297
-wizelit_sdk-0.1.30.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-wizelit_sdk-0.1.30.dist-info/RECORD,,
+wizelit_sdk-0.1.32.dist-info/METADATA,sha256=94NCVGl52cRNM7Z7z93l-jwh-OAdmMx-uBx_dPymBAg,5787
+wizelit_sdk-0.1.32.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+wizelit_sdk-0.1.32.dist-info/entry_points.txt,sha256=XRtYie5Jhxb5xv0Kda2OwA1k6fuf4utEttjo29sJ2FM,53
+wizelit_sdk-0.1.32.dist-info/RECORD,,

wizelit_sdk-0.1.32.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wizelit-sdk = wizelit_sdk.cli:main

wizelit_sdk-0.1.30.dist-info/METADATA

@@ -1,124 +0,0 @@
-Metadata-Version: 2.4
-Name: wizelit-sdk
-Version: 0.1.30
-Summary: Wizelit Agent Wrapper - Internal utility package
-Author-email: Your Name <your.email@company.com>
-Requires-Python: >=3.10
-Requires-Dist: asyncpg>=0.26.0
-Requires-Dist: fastmcp>=0.1.0
-Requires-Dist: redis>=4.5.0
-Requires-Dist: sqlalchemy>=1.4
-Requires-Dist: typeguard>=4.3.0
-Requires-Dist: typing-extensions>=4.0.0
-Provides-Extra: dev
-Requires-Dist: black>=22.0.0; extra == 'dev'
-Requires-Dist: build>=1.0.0; extra == 'dev'
-Requires-Dist: pytest>=7.0.0; extra == 'dev'
-Requires-Dist: ruff>=0.1.0; extra == 'dev'
-Provides-Extra: streaming
-Requires-Dist: redis>=4.5.0; extra == 'streaming'
-Description-Content-Type: text/markdown
-
-# wizelit-sdk
-
-Internal utility package for Wizelit Agent operations.
-
-## Installation
-
-### Install from Git Repository
-
-```bash
-# Install latest version from main branch
-uv pip install git+https://github.com/your-org/wizelit-sdk.git
-
-# Install specific version
-uv pip install git+https://github.com/your-org/wizelit-sdk.git@v0.1.0
-
-# Install with SSH (Recommended for Private Repos)
-uv pip install git+ssh://git@github.com/your-org/wizelit-sdk.git@v0.1.0
-```
-
-### Add to pyproject.toml
-
-```toml
-[project]
-dependencies = [
-    "wizelit-sdk @ git+ssh://git@github.com/your-org/wizelit-sdk.git@v0.1.0"
-]
-```
-
-## Usage
-
-```python
-from wizelit_agent_wrapper import your_module
-
-# Use the wrapper
-result = your_module.function()
-```
-
-## Configuration
-
-The SDK reads database configuration from the hosting application's environment. Provide these variables in the consuming project (e.g., via your app's .env or deployment secrets):
-
-- POSTGRES_USER
-- POSTGRES_PASSWORD
-- POSTGRES_HOST
-- POSTGRES_PORT
-- POSTGRES_DB
-
-You can also supply a full connection string via `DATABASE_URL` (overrides the individual fields). If using streaming/logging with Redis, set `REDIS_HOST`, `REDIS_PORT`, and optionally `REDIS_PASSWORD`.
-
-## Development
-
-### Setup Development Environment
-
-```bash
-# Clone repository
-git clone https://github.com/your-org/wizelit-sdk.git
-cd wizelit-sdk
-
-# Set up environment
-make setup
-
-# Activate virtual environment
-source .venv/bin/activate  # Windows: .venv\Scripts\activate
-
-# Install in development mode
-make install-dev
-```
-
-### Available Make Commands
-
-```bash
-make setup          # Set up development environment
-make install-dev    # Install in development mode
-make test           # Run tests
-make format         # Format code with black
-make lint           # Lint code with ruff
-make check          # Run tests and linting
-make clean          # Clean build artifacts
-make build          # Build package
-make release        # Create new release (interactive)
-make tag VERSION=x.x.x  # Create specific version tag
-make push           # Push code and tags
-make version        # Show current version
-make versions       # List all available versions
-```
-
-## Contributing
-
-1. Create a feature branch
-2. Make your changes
-3. Run tests and linting: `make check`
-4. Commit your changes
-5. Push and create a pull request
-
-## Versioning
-
-We use [Semantic Versioning](https://semver.org/):
-
-- **MAJOR** version for incompatible API changes
-- **MINOR** version for new functionality (backward compatible)
-- **PATCH** version for bug fixes
-
-See [CHANGELOG.md](CHANGELOG.md) for version history.