publish_assistant.py

#!/usr/bin/env python3
"""
🚀 AgentCoach PyPI Publishing Assistant

A Streamlit app to help publish agentcoach to PyPI with guided steps and checks.

Usage:
    streamlit run publish_assistant.py
"""

import json
import subprocess
import sys
from pathlib import Path
from typing import Optional, Tuple

try:
    import streamlit as st
    import toml
except ImportError:
    print("❌ Missing dependencies. Install with:")
    print("   pip install streamlit toml")
    sys.exit(1)


def run_command(cmd: list[str], capture: bool = True) -> Tuple[bool, str]:
    """Run a shell command and return success status and output."""
    try:
        if capture:
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                check=False
            )
            return result.returncode == 0, result.stdout + result.stderr
        else:
            result = subprocess.run(cmd, check=False)
            return result.returncode == 0, ""
    except Exception as e:
        return False, str(e)


def check_git_status() -> Tuple[bool, str]:
    """Check if git working directory is clean."""
    success, output = run_command(["git", "status", "--porcelain"])
    if not success:
        return False, "Git not available or not a git repository"
    is_clean = len(output.strip()) == 0
    return is_clean, "Clean" if is_clean else "Uncommitted changes"


def check_tests() -> Tuple[bool, str]:
    """Run pytest and check if tests pass."""
    success, output = run_command(["pytest", "-q"])
    return success, output if success else "Tests failed"


def get_current_version() -> str:
    """Get current version from pyproject.toml."""
    try:
        with open("pyproject.toml") as f:
            data = toml.load(f)
            return data["project"]["version"]
    except Exception as e:
        return f"Error: {e}"


def calculate_new_version(current: str, bump_type: str) -> str:
    """Calculate new version based on bump type."""
    try:
        parts = current.split(".")
        major, minor, patch = int(parts[0]), int(parts[1]), int(parts[2])
        
        if bump_type == "major":
            return f"{major + 1}.0.0"
        elif bump_type == "minor":
            return f"{major}.{minor + 1}.0"
        else:  # patch
            return f"{major}.{minor}.{patch + 1}"
    except Exception:
        return "Error calculating version"


def update_version_in_file(new_version: str) -> bool:
    """Update version in pyproject.toml."""
    try:
        with open("pyproject.toml") as f:
            content = f.read()
        
        # Replace version line
        import re
        content = re.sub(
            r'version = "[^"]+"',
            f'version = "{new_version}"',
            content
        )
        
        with open("pyproject.toml", "w") as f:
            f.write(content)
        
        return True
    except Exception as e:
        st.error(f"Failed to update version: {e}")
        return False


def main():
    st.set_page_config(
        page_title="AgentCoach PyPI Publisher",
        page_icon="🚀",
        layout="wide"
    )
    
    st.title("🚀 AgentCoach PyPI Publishing Assistant")
    st.markdown("*Guided workflow for publishing to PyPI*")
    
    # Sidebar with quick links
    with st.sidebar:
        st.header("📚 Resources")
        st.markdown("""
        - [PyPI](https://pypi.org)
        - [TestPyPI](https://test.pypi.org)
        - [Publishing Guide](PUBLISHING.md)
        - [Changelog](CHANGELOG.md)
        """)
        
        st.header("⚙️ Settings")
        use_testpypi = st.checkbox("Test on TestPyPI first", value=True)
        auto_tag = st.checkbox("Auto-create git tag", value=True)
    
    # Main workflow
    tabs = st.tabs([
        "1️⃣ Pre-flight",
        "2️⃣ Version",
        "3️⃣ Build",
        "4️⃣ Test",
        "5️⃣ Publish"
    ])
    
    # Tab 1: Pre-flight Checks
    with tabs[0]:
        st.header("Pre-flight Checks")
        st.markdown("Verify everything is ready for publishing")
        
        if st.button("🔍 Run All Checks", type="primary"):
            with st.spinner("Running checks..."):
                checks = {}
                
                # Check 1: Files exist
                checks["pyproject.toml"] = Path("pyproject.toml").exists()
                checks["README.md"] = Path("README.md").exists()
                checks["LICENSE"] = Path("LICENSE").exists()
                checks["CHANGELOG.md"] = Path("CHANGELOG.md").exists()
                
                # Check 2: Git status
                git_clean, git_msg = check_git_status()
                checks["Git clean"] = git_clean
                
                # Check 3: Tests
                if st.session_state.get("run_tests", True):
                    tests_pass, test_output = check_tests()
                    checks["Tests pass"] = tests_pass
                    if not tests_pass:
                        st.code(test_output, language="text")
                
                # Display results
                for check, passed in checks.items():
                    if passed:
                        st.success(f"✅ {check}")
                    else:
                        st.error(f"❌ {check}")
                
                all_passed = all(checks.values())
                if all_passed:
                    st.balloons()
                    st.success("🎉 All checks passed! Ready to proceed.")
                else:
                    st.warning("⚠️ Some checks failed. Fix issues before publishing.")
        
        st.checkbox("Skip tests (not recommended)", key="skip_tests")
    
    # Tab 2: Version Management
    with tabs[1]:
        st.header("Version Management")
        
        current_version = get_current_version()
        st.info(f"📌 Current version: **{current_version}**")
        
        col1, col2 = st.columns(2)
        
        with col1:
            bump_type = st.selectbox(
                "Bump type",
                ["patch", "minor", "major"],
                help="patch: 0.1.0→0.1.1, minor: 0.1.0→0.2.0, major: 0.1.0→1.0.0"
            )
        
        with col2:
            new_version = calculate_new_version(current_version, bump_type)
            st.metric("New version", new_version)
        
        st.markdown("---")
        
        # Manual version override
        manual_version = st.text_input(
            "Or enter version manually",
            placeholder="e.g., 0.2.0"
        )
        
        if manual_version:
            new_version = manual_version
        
        if st.button("📝 Update Version", type="primary"):
            if update_version_in_file(new_version):
                st.success(f"✅ Version updated to {new_version}")
                st.info("💡 Don't forget to update CHANGELOG.md!")
            else:
                st.error("❌ Failed to update version")
        
        # Changelog reminder
        st.markdown("### 📋 Changelog")
        st.markdown("Add an entry to CHANGELOG.md:")
        st.code(f"""
## [{new_version}] - {Path('CHANGELOG.md').stat().st_mtime if Path('CHANGELOG.md').exists() else 'YYYY-MM-DD'}

### Added
- New feature

### Fixed
- Bug fix

### Changed
- Improvement
        """, language="markdown")
    
    # Tab 3: Build
    with tabs[2]:
        st.header("Build Package")
        
        st.markdown("""
        This will create distribution files in the `dist/` directory:
        - Source distribution (`.tar.gz`)
        - Wheel (`.whl`)
        """)
        
        if st.button("🔨 Build Package", type="primary"):
            with st.spinner("Building..."):
                # Clean previous builds
                st.info("Cleaning previous builds...")
                run_command(["rm", "-rf", "dist/", "build/", "*.egg-info"])
                
                # Build
                st.info("Building package...")
                success, output = run_command(["python", "-m", "build"])
                
                if success:
                    st.success("✅ Build successful!")
                    st.code(output, language="text")
                    
                    # Show built files
                    dist_files = list(Path("dist").glob("*"))
                    if dist_files:
                        st.markdown("**Built files:**")
                        for f in dist_files:
                            st.text(f"  📦 {f.name}")
                    
                    # Check package
                    st.info("Checking package...")
                    check_success, check_output = run_command(
                        ["twine", "check", "dist/*"]
                    )
                    if check_success:
                        st.success("✅ Package check passed")
                    else:
                        st.error("❌ Package check failed")
                        st.code(check_output, language="text")
                else:
                    st.error("❌ Build failed")
                    st.code(output, language="text")
    
    # Tab 4: Test on TestPyPI
    with tabs[3]:
        st.header("Test on TestPyPI")
        
        if not use_testpypi:
            st.warning("⚠️ TestPyPI testing is disabled. Enable in sidebar.")
        else:
            st.markdown("""
            Upload to TestPyPI to verify everything works before publishing to production PyPI.
            
            **You'll need:**
            - TestPyPI account: https://test.pypi.org
            - API token from TestPyPI
            """)
            
            testpypi_token = st.text_input(
                "TestPyPI API Token",
                type="password",
                help="Get from https://test.pypi.org/manage/account/token/"
            )
            
            if st.button("📤 Upload to TestPyPI", type="primary", disabled=not testpypi_token):
                with st.spinner("Uploading to TestPyPI..."):
                    # Set environment variables for twine
                    import os
                    os.environ["TWINE_USERNAME"] = "__token__"
                    os.environ["TWINE_PASSWORD"] = testpypi_token
                    
                    success, output = run_command([
                        "twine", "upload",
                        "--repository", "testpypi",
                        "dist/*"
                    ])
                    
                    if success:
                        st.success("✅ Uploaded to TestPyPI!")
                        st.markdown(f"""
                        **Test installation:**
                        ```bash
                        pip install --index-url https://test.pypi.org/simple/ \\
                            --extra-index-url https://pypi.org/simple/ \\
                            agentcoach
                        ```
                        
                        **View on TestPyPI:**
                        https://test.pypi.org/project/agentcoach/
                        """)
                    else:
                        st.error("❌ Upload failed")
                        st.code(output, language="text")
    
    # Tab 5: Publish to PyPI
    with tabs[4]:
        st.header("🚀 Publish to PyPI")
        
        st.warning("""
        ⚠️ **Warning:** This will publish to production PyPI.
        Make sure you've tested on TestPyPI first!
        """)
        
        st.markdown("""
        **You'll need:**
        - PyPI account: https://pypi.org
        - API token from PyPI
        """)
        
        pypi_token = st.text_input(
            "PyPI API Token",
            type="password",
            help="Get from https://pypi.org/manage/account/token/"
        )
        
        confirm = st.checkbox("I confirm I want to publish to PyPI")
        
        if st.button(
            "🚀 Publish to PyPI",
            type="primary",
            disabled=not (pypi_token and confirm)
        ):
            with st.spinner("Publishing to PyPI..."):
                # Set environment variables for twine
                import os
                os.environ["TWINE_USERNAME"] = "__token__"
                os.environ["TWINE_PASSWORD"] = pypi_token
                
                success, output = run_command(["twine", "upload", "dist/*"])
                
                if success:
                    st.success("🎉 Published to PyPI!")
                    st.balloons()
                    
                    version = get_current_version()
                    st.markdown(f"""
                    **Installation:**
                    ```bash
                    pip install agentcoach
                    ```
                    
                    **View on PyPI:**
                    https://pypi.org/project/agentcoach/{version}/
                    """)
                    
                    # Git tag
                    if auto_tag:
                        st.info("Creating git tag...")
                        tag_name = f"v{version}"
                        run_command(["git", "tag", "-a", tag_name, "-m", f"Release {version}"])
                        st.success(f"✅ Created tag: {tag_name}")
                        st.info("💡 Don't forget to push tags: `git push origin --tags`")
                else:
                    st.error("❌ Publish failed")
                    st.code(output, language="text")
    
    # Footer
    st.markdown("---")
    st.markdown("""
    <div style='text-align: center; color: gray;'>
    📚 See <a href='PUBLISHING.md'>PUBLISHING.md</a> for detailed instructions
    </div>
    """, unsafe_allow_html=True)


if __name__ == "__main__":
    # Check if we're in the right directory
    if not Path("pyproject.toml").exists():
        st.error("❌ pyproject.toml not found. Run this from the project root directory.")
        st.stop()
    
    main()