skill-seekers 2.7.3__py3-none-any.whl

skill_seekers/mcp/tools/packaging_tools.py

@@ -0,0 +1,826 @@
+"""
+Packaging tools for MCP server.
+
+This module contains tools for packaging, uploading, and installing skills.
+Extracted from server.py for better modularity.
+"""
+
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+try:
+    from mcp.types import TextContent
+except ImportError:
+    # Graceful degradation: Create a simple fallback class for testing
+    class TextContent:
+        """Fallback TextContent for when MCP is not installed"""
+
+        def __init__(self, type: str, text: str):
+            self.type = type
+            self.text = text
+
+
+# Path to CLI tools
+CLI_DIR = Path(__file__).parent.parent.parent / "cli"
+
+
+def run_subprocess_with_streaming(cmd: list[str], timeout: int = None) -> tuple[str, str, int]:
+    """
+    Run subprocess with real-time output streaming.
+
+    This solves the blocking issue where long-running processes (like scraping)
+    would cause MCP to appear frozen. Now we stream output as it comes.
+
+    Args:
+        cmd: Command to run as list of strings
+        timeout: Maximum time to wait in seconds (None for no timeout)
+
+    Returns:
+        Tuple of (stdout, stderr, returncode)
+    """
+    try:
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,  # Line buffered
+            universal_newlines=True,
+        )
+
+        stdout_lines = []
+        stderr_lines = []
+        start_time = time.time()
+
+        # Read output line by line as it comes
+        while True:
+            # Check timeout
+            if timeout and (time.time() - start_time) > timeout:
+                process.kill()
+                stderr_lines.append(f"\n⚠️ Process killed after {timeout}s timeout")
+                break
+
+            # Check if process finished
+            if process.poll() is not None:
+                break
+
+            # Read available output (non-blocking)
+            try:
+                import select
+
+                readable, _, _ = select.select([process.stdout, process.stderr], [], [], 0.1)
+
+                if process.stdout in readable:
+                    line = process.stdout.readline()
+                    if line:
+                        stdout_lines.append(line)
+
+                if process.stderr in readable:
+                    line = process.stderr.readline()
+                    if line:
+                        stderr_lines.append(line)
+            except Exception:
+                # Fallback for Windows (no select)
+                time.sleep(0.1)
+
+        # Get any remaining output
+        remaining_stdout, remaining_stderr = process.communicate()
+        if remaining_stdout:
+            stdout_lines.append(remaining_stdout)
+        if remaining_stderr:
+            stderr_lines.append(remaining_stderr)
+
+        stdout = "".join(stdout_lines)
+        stderr = "".join(stderr_lines)
+        returncode = process.returncode
+
+        return stdout, stderr, returncode
+
+    except Exception as e:
+        return "", f"Error running subprocess: {str(e)}", 1
+
+
+async def package_skill_tool(args: dict) -> list[TextContent]:
+    """
+    Package skill for target LLM platform and optionally auto-upload.
+
+    Args:
+        args: Dictionary with:
+            - skill_dir (str): Path to skill directory (e.g., output/react/)
+            - auto_upload (bool): Try to upload automatically if API key is available (default: True)
+            - target (str): Target platform (default: 'claude')
+                           Options: 'claude', 'gemini', 'openai', 'markdown'
+
+    Returns:
+        List of TextContent with packaging results
+    """
+    from skill_seekers.cli.adaptors import get_adaptor
+
+    skill_dir = args["skill_dir"]
+    auto_upload = args.get("auto_upload", True)
+    target = args.get("target", "claude")
+
+    # Get platform adaptor
+    try:
+        adaptor = get_adaptor(target)
+    except ValueError as e:
+        return [
+            TextContent(
+                type="text",
+                text=f"❌ Invalid platform: {str(e)}\n\nSupported platforms: claude, gemini, openai, markdown",
+            )
+        ]
+
+    # Check if platform-specific API key exists - only upload if available
+    env_var_name = adaptor.get_env_var_name()
+    has_api_key = os.environ.get(env_var_name, "").strip() if env_var_name else False
+    should_upload = auto_upload and has_api_key
+
+    # Run package_skill.py with target parameter
+    cmd = [
+        sys.executable,
+        str(CLI_DIR / "package_skill.py"),
+        skill_dir,
+        "--no-open",  # Don't open folder in MCP context
+        "--skip-quality-check",  # Skip interactive quality checks in MCP context
+        "--target",
+        target,  # Add target platform
+    ]
+
+    # Add upload flag only if we have API key
+    if should_upload:
+        cmd.append("--upload")
+
+    # Timeout: 5 minutes for packaging + upload
+    timeout = 300
+
+    progress_msg = f"📦 Packaging skill for {adaptor.PLATFORM_NAME}...\n"
+    if should_upload:
+        progress_msg += f"📤 Will auto-upload to {adaptor.PLATFORM_NAME} if successful\n"
+    progress_msg += f"⏱️ Maximum time: {timeout // 60} minutes\n\n"
+
+    stdout, stderr, returncode = run_subprocess_with_streaming(cmd, timeout=timeout)
+
+    output = progress_msg + stdout
+
+    if returncode == 0:
+        if should_upload:
+            # Upload succeeded
+            output += f"\n\n✅ Skill packaged and uploaded to {adaptor.PLATFORM_NAME}!"
+            if target == "claude":
+                output += "\n   Your skill is now available in Claude!"
+                output += "\n   Go to https://claude.ai/skills to use it"
+            elif target == "gemini":
+                output += "\n   Your skill is now available in Gemini!"
+                output += "\n   Go to https://aistudio.google.com/ to use it"
+            elif target == "openai":
+                output += "\n   Your assistant is now available in OpenAI!"
+                output += "\n   Go to https://platform.openai.com/assistants/ to use it"
+        elif auto_upload and not has_api_key:
+            # User wanted upload but no API key
+            output += f"\n\n📝 Skill packaged successfully for {adaptor.PLATFORM_NAME}!"
+            output += "\n"
+            output += "\n💡 To enable automatic upload:"
+            if target == "claude":
+                output += "\n   1. Get API key from https://console.anthropic.com/"
+                output += "\n   2. Set: export ANTHROPIC_API_KEY=sk-ant-..."
+                output += "\n\n📤 Manual upload:"
+                output += "\n   1. Find the .zip file in your output/ folder"
+                output += "\n   2. Go to https://claude.ai/skills"
+                output += "\n   3. Click 'Upload Skill' and select the .zip file"
+            elif target == "gemini":
+                output += "\n   1. Get API key from https://aistudio.google.com/"
+                output += "\n   2. Set: export GOOGLE_API_KEY=AIza..."
+                output += "\n\n📤 Manual upload:"
+                output += "\n   1. Go to https://aistudio.google.com/"
+                output += "\n   2. Upload the .tar.gz file from your output/ folder"
+            elif target == "openai":
+                output += "\n   1. Get API key from https://platform.openai.com/"
+                output += "\n   2. Set: export OPENAI_API_KEY=sk-proj-..."
+                output += "\n\n📤 Manual upload:"
+                output += "\n   1. Use OpenAI Assistants API"
+                output += "\n   2. Upload the .zip file from your output/ folder"
+            elif target == "markdown":
+                output += "\n   (No API key needed - markdown is export only)"
+                output += "\n   Package created for manual distribution"
+        else:
+            # auto_upload=False, just packaged
+            output += f"\n\n✅ Skill packaged successfully for {adaptor.PLATFORM_NAME}!"
+            if target == "claude":
+                output += "\n   Upload manually to https://claude.ai/skills"
+            elif target == "gemini":
+                output += "\n   Upload manually to https://aistudio.google.com/"
+            elif target == "openai":
+                output += "\n   Upload manually via OpenAI Assistants API"
+            elif target == "markdown":
+                output += "\n   Package ready for manual distribution"
+
+        return [TextContent(type="text", text=output)]
+    else:
+        return [TextContent(type="text", text=f"{output}\n\n❌ Error:\n{stderr}")]
+
+
+async def upload_skill_tool(args: dict) -> list[TextContent]:
+    """
+    Upload skill package to target LLM platform.
+
+    Args:
+        args: Dictionary with:
+            - skill_zip (str): Path to skill package (.zip or .tar.gz)
+            - target (str): Target platform (default: 'claude')
+                           Options: 'claude', 'gemini', 'openai'
+                           Note: 'markdown' does not support upload
+            - api_key (str, optional): API key (uses env var if not provided)
+
+    Returns:
+        List of TextContent with upload results
+    """
+    from skill_seekers.cli.adaptors import get_adaptor
+
+    skill_zip = args["skill_zip"]
+    target = args.get("target", "claude")
+    api_key = args.get("api_key")
+
+    # Get platform adaptor
+    try:
+        adaptor = get_adaptor(target)
+    except ValueError as e:
+        return [
+            TextContent(
+                type="text",
+                text=f"❌ Invalid platform: {str(e)}\n\nSupported platforms: claude, gemini, openai",
+            )
+        ]
+
+    # Check if upload is supported
+    if target == "markdown":
+        return [
+            TextContent(
+                type="text",
+                text="❌ Markdown export does not support upload. Use the packaged file manually.",
+            )
+        ]
+
+    # Run upload_skill.py with target parameter
+    cmd = [sys.executable, str(CLI_DIR / "upload_skill.py"), skill_zip, "--target", target]
+
+    # Add API key if provided
+    if api_key:
+        cmd.extend(["--api-key", api_key])
+
+    # Timeout: 5 minutes for upload
+    timeout = 300
+
+    progress_msg = f"📤 Uploading skill to {adaptor.PLATFORM_NAME}...\n"
+    progress_msg += f"⏱️ Maximum time: {timeout // 60} minutes\n\n"
+
+    stdout, stderr, returncode = run_subprocess_with_streaming(cmd, timeout=timeout)
+
+    output = progress_msg + stdout
+
+    if returncode == 0:
+        return [TextContent(type="text", text=output)]
+    else:
+        return [TextContent(type="text", text=f"{output}\n\n❌ Error:\n{stderr}")]
+
+
+async def enhance_skill_tool(args: dict) -> list[TextContent]:
+    """
+    Enhance SKILL.md with AI using target platform's model.
+
+    Args:
+        args: Dictionary with:
+            - skill_dir (str): Path to skill directory
+            - target (str): Target platform (default: 'claude')
+                           Options: 'claude', 'gemini', 'openai'
+                           Note: 'markdown' does not support enhancement
+            - mode (str): Enhancement mode (default: 'local')
+                         'local': Uses Claude Code Max (no API key)
+                         'api': Uses platform API (requires API key)
+            - api_key (str, optional): API key for 'api' mode
+
+    Returns:
+        List of TextContent with enhancement results
+    """
+    from skill_seekers.cli.adaptors import get_adaptor
+
+    skill_dir = Path(args.get("skill_dir"))
+    target = args.get("target", "claude")
+    mode = args.get("mode", "local")
+    api_key = args.get("api_key")
+
+    # Validate skill directory
+    if not skill_dir.exists():
+        return [TextContent(type="text", text=f"❌ Skill directory not found: {skill_dir}")]
+
+    if not (skill_dir / "SKILL.md").exists():
+        return [TextContent(type="text", text=f"❌ SKILL.md not found in {skill_dir}")]
+
+    # Get platform adaptor
+    try:
+        adaptor = get_adaptor(target)
+    except ValueError as e:
+        return [
+            TextContent(
+                type="text",
+                text=f"❌ Invalid platform: {str(e)}\n\nSupported platforms: claude, gemini, openai",
+            )
+        ]
+
+    # Check if enhancement is supported
+    if not adaptor.supports_enhancement():
+        return [
+            TextContent(
+                type="text", text=f"❌ {adaptor.PLATFORM_NAME} does not support AI enhancement"
+            )
+        ]
+
+    output_lines = []
+    output_lines.append(f"🚀 Enhancing skill with {adaptor.PLATFORM_NAME}")
+    output_lines.append("-" * 70)
+    output_lines.append(f"Skill directory: {skill_dir}")
+    output_lines.append(f"Mode: {mode}")
+    output_lines.append("")
+
+    if mode == "local":
+        # Use local enhancement (Claude Code)
+        output_lines.append("Using Claude Code Max (local, no API key required)")
+        output_lines.append("Running enhancement in headless mode...")
+        output_lines.append("")
+
+        cmd = [sys.executable, str(CLI_DIR / "enhance_skill_local.py"), str(skill_dir)]
+
+        try:
+            stdout, stderr, returncode = run_subprocess_with_streaming(cmd, timeout=900)
+
+            if returncode == 0:
+                output_lines.append(stdout)
+                output_lines.append("")
+                output_lines.append("✅ Enhancement complete!")
+                output_lines.append(f"Enhanced SKILL.md: {skill_dir / 'SKILL.md'}")
+                output_lines.append(f"Backup: {skill_dir / 'SKILL.md.backup'}")
+            else:
+                output_lines.append(f"❌ Enhancement failed (exit code {returncode})")
+                output_lines.append(stderr if stderr else stdout)
+
+        except Exception as e:
+            output_lines.append(f"❌ Error: {str(e)}")
+
+    elif mode == "api":
+        # Use API enhancement
+        output_lines.append(f"Using {adaptor.PLATFORM_NAME} API")
+
+        # Get API key
+        if not api_key:
+            env_var = adaptor.get_env_var_name()
+            api_key = os.environ.get(env_var)
+
+            if not api_key:
+                return [
+                    TextContent(
+                        type="text",
+                        text=f"❌ {env_var} not set. Set API key or pass via api_key parameter.",
+                    )
+                ]
+
+        # Validate API key
+        if not adaptor.validate_api_key(api_key):
+            return [
+                TextContent(
+                    type="text", text=f"❌ Invalid API key format for {adaptor.PLATFORM_NAME}"
+                )
+            ]
+
+        output_lines.append("Calling API for enhancement...")
+        output_lines.append("")
+
+        try:
+            success = adaptor.enhance(skill_dir, api_key)
+
+            if success:
+                output_lines.append("✅ Enhancement complete!")
+                output_lines.append(f"Enhanced SKILL.md: {skill_dir / 'SKILL.md'}")
+                output_lines.append(f"Backup: {skill_dir / 'SKILL.md.backup'}")
+            else:
+                output_lines.append("❌ Enhancement failed")
+
+        except Exception as e:
+            output_lines.append(f"❌ Error: {str(e)}")
+
+    else:
+        return [TextContent(type="text", text=f"❌ Invalid mode: {mode}. Use 'local' or 'api'")]
+
+    return [TextContent(type="text", text="\n".join(output_lines))]
+
+
+async def install_skill_tool(args: dict) -> list[TextContent]:
+    """
+    Complete skill installation workflow.
+
+    Orchestrates the complete workflow:
+        1. Fetch config (if config_name provided)
+        2. Scrape documentation
+        3. AI Enhancement (MANDATORY - no skip option)
+        4. Package for target platform (ZIP or tar.gz)
+        5. Upload to target platform (optional)
+
+    Args:
+        args: Dictionary with:
+            - config_name (str, optional): Config to fetch from API (mutually exclusive with config_path)
+            - config_path (str, optional): Path to existing config (mutually exclusive with config_name)
+            - destination (str): Output directory (default: "output")
+            - auto_upload (bool): Upload after packaging (default: True)
+            - unlimited (bool): Remove page limits (default: False)
+            - dry_run (bool): Preview only (default: False)
+            - target (str): Target LLM platform (default: "claude")
+
+    Returns:
+        List of TextContent with workflow progress and results
+    """
+    # Import these here to avoid circular imports
+    from skill_seekers.cli.adaptors import get_adaptor
+
+    from .scraping_tools import scrape_docs_tool
+    from .source_tools import fetch_config_tool
+
+    # Extract and validate inputs
+    config_name = args.get("config_name")
+    config_path = args.get("config_path")
+    destination = args.get("destination", "output")
+    auto_upload = args.get("auto_upload", True)
+    unlimited = args.get("unlimited", False)
+    dry_run = args.get("dry_run", False)
+    target = args.get("target", "claude")
+
+    # Get platform adaptor
+    try:
+        adaptor = get_adaptor(target)
+    except ValueError as e:
+        return [
+            TextContent(
+                type="text",
+                text=f"❌ Error: {str(e)}\n\nSupported platforms: claude, gemini, openai, markdown",
+            )
+        ]
+
+    # Validation: Must provide exactly one of config_name or config_path
+    if not config_name and not config_path:
+        return [
+            TextContent(
+                type="text",
+                text="❌ Error: Must provide either config_name or config_path\n\nExamples:\n  install_skill(config_name='react')\n  install_skill(config_path='configs/custom.json')",
+            )
+        ]
+
+    if config_name and config_path:
+        return [
+            TextContent(
+                type="text",
+                text="❌ Error: Cannot provide both config_name and config_path\n\nChoose one:\n  - config_name: Fetch from API (e.g., 'react')\n  - config_path: Use existing file (e.g., 'configs/custom.json')",
+            )
+        ]
+
+    # Initialize output
+    output_lines = []
+    output_lines.append("🚀 SKILL INSTALLATION WORKFLOW")
+    output_lines.append("=" * 70)
+    output_lines.append("")
+
+    if dry_run:
+        output_lines.append("🔍 DRY RUN MODE - Preview only, no actions taken")
+        output_lines.append("")
+
+    # Track workflow state
+    workflow_state = {
+        "config_path": config_path,
+        "skill_name": None,
+        "skill_dir": None,
+        "zip_path": None,
+        "phases_completed": [],
+    }
+
+    try:
+        # ===== PHASE 1: Fetch Config (if needed) =====
+        if config_name:
+            output_lines.append("📥 PHASE 1/5: Fetch Config")
+            output_lines.append("-" * 70)
+            output_lines.append(f"Config: {config_name}")
+            output_lines.append(f"Destination: {destination}/")
+            output_lines.append("")
+
+            if not dry_run:
+                # Call fetch_config_tool directly
+                fetch_result = await fetch_config_tool(
+                    {"config_name": config_name, "destination": destination}
+                )
+
+                # Parse result to extract config path
+                fetch_output = fetch_result[0].text
+                output_lines.append(fetch_output)
+                output_lines.append("")
+
+                # Extract config path from output
+                # Expected format: "📂 Saved to: configs/react.json"
+                match = re.search(r"(?i)saved to:\s*(.+\.json)", fetch_output)
+                if match:
+                    workflow_state["config_path"] = match.group(1).strip()
+                    output_lines.append(f"✅ Config fetched: {workflow_state['config_path']}")
+                else:
+                    return [
+                        TextContent(
+                            type="text",
+                            text="\n".join(output_lines) + "\n\n❌ Failed to fetch config",
+                        )
+                    ]
+
+                workflow_state["phases_completed"].append("fetch_config")
+            else:
+                output_lines.append("  [DRY RUN] Would fetch config from API")
+                workflow_state["config_path"] = f"{destination}/{config_name}.json"
+
+            output_lines.append("")
+
+        # ===== PHASE 2: Scrape Documentation =====
+        phase_num = "2/5" if config_name else "1/4"
+        output_lines.append(f"📄 PHASE {phase_num}: Scrape Documentation")
+        output_lines.append("-" * 70)
+        output_lines.append(f"Config: {workflow_state['config_path']}")
+        output_lines.append(f"Unlimited mode: {unlimited}")
+        output_lines.append("")
+
+        if not dry_run:
+            # Load config to get skill name
+            try:
+                with open(workflow_state["config_path"]) as f:
+                    config = json.load(f)
+                    workflow_state["skill_name"] = config.get("name", "unknown")
+            except Exception as e:
+                return [
+                    TextContent(
+                        type="text",
+                        text="\n".join(output_lines) + f"\n\n❌ Failed to read config: {str(e)}",
+                    )
+                ]
+
+            # Call scrape_docs_tool (does NOT include enhancement)
+            output_lines.append("Scraping documentation (this may take 20-45 minutes)...")
+            output_lines.append("")
+
+            scrape_result = await scrape_docs_tool(
+                {
+                    "config_path": workflow_state["config_path"],
+                    "unlimited": unlimited,
+                    "enhance_local": False,  # Enhancement is separate phase
+                    "skip_scrape": False,
+                    "dry_run": False,
+                }
+            )
+
+            scrape_output = scrape_result[0].text
+            output_lines.append(scrape_output)
+            output_lines.append("")
+
+            # Check for success
+            if "❌" in scrape_output:
+                return [
+                    TextContent(
+                        type="text",
+                        text="\n".join(output_lines) + "\n\n❌ Scraping failed - see error above",
+                    )
+                ]
+
+            workflow_state["skill_dir"] = f"{destination}/{workflow_state['skill_name']}"
+            workflow_state["phases_completed"].append("scrape_docs")
+        else:
+            output_lines.append("  [DRY RUN] Would scrape documentation")
+            workflow_state["skill_name"] = "example"
+            workflow_state["skill_dir"] = f"{destination}/example"
+
+        output_lines.append("")
+
+        # ===== PHASE 3: AI Enhancement (MANDATORY) =====
+        phase_num = "3/5" if config_name else "2/4"
+        output_lines.append(f"✨ PHASE {phase_num}: AI Enhancement (MANDATORY)")
+        output_lines.append("-" * 70)
+        output_lines.append("⚠️  Enhancement is REQUIRED for quality (3/10→9/10 boost)")
+        output_lines.append(f"Skill directory: {workflow_state['skill_dir']}")
+        output_lines.append("Mode: Headless (runs in background)")
+        output_lines.append("Estimated time: 30-60 seconds")
+        output_lines.append("")
+
+        if not dry_run:
+            # Run enhance_skill_local in headless mode
+            # Build command directly
+            cmd = [
+                sys.executable,
+                str(CLI_DIR / "enhance_skill_local.py"),
+                workflow_state["skill_dir"],
+                # Headless is default, no flag needed
+            ]
+
+            timeout = 900  # 15 minutes max for enhancement
+
+            output_lines.append("Running AI enhancement...")
+
+            stdout, stderr, returncode = run_subprocess_with_streaming(cmd, timeout=timeout)
+
+            if returncode != 0:
+                output_lines.append(f"\n❌ Enhancement failed (exit code {returncode}):")
+                output_lines.append(stderr if stderr else stdout)
+                return [TextContent(type="text", text="\n".join(output_lines))]
+
+            output_lines.append(stdout)
+            workflow_state["phases_completed"].append("enhance_skill")
+        else:
+            output_lines.append("  [DRY RUN] Would enhance SKILL.md with Claude Code")
+
+        output_lines.append("")
+
+        # ===== PHASE 4: Package Skill =====
+        phase_num = "4/5" if config_name else "3/4"
+        output_lines.append(f"📦 PHASE {phase_num}: Package Skill for {adaptor.PLATFORM_NAME}")
+        output_lines.append("-" * 70)
+        output_lines.append(f"Skill directory: {workflow_state['skill_dir']}")
+        output_lines.append(f"Target platform: {adaptor.PLATFORM_NAME}")
+        output_lines.append("")
+
+        if not dry_run:
+            # Call package_skill_tool with target
+            package_result = await package_skill_tool(
+                {
+                    "skill_dir": workflow_state["skill_dir"],
+                    "auto_upload": False,  # We handle upload in next phase
+                    "target": target,
+                }
+            )
+
+            package_output = package_result[0].text
+            output_lines.append(package_output)
+            output_lines.append("")
+
+            # Extract package path from output (supports .zip and .tar.gz)
+            # Expected format: "Saved to: output/react.zip" or "Saved to: output/react-gemini.tar.gz"
+            match = re.search(r"(?i)saved to:\s*(.+\.(?:zip|tar\.gz))", package_output)
+            if match:
+                workflow_state["zip_path"] = match.group(1).strip()
+            else:
+                # Fallback: construct package path based on platform
+                if target == "gemini":
+                    workflow_state["zip_path"] = (
+                        f"{destination}/{workflow_state['skill_name']}-gemini.tar.gz"
+                    )
+                elif target == "openai":
+                    workflow_state["zip_path"] = (
+                        f"{destination}/{workflow_state['skill_name']}-openai.zip"
+                    )
+                else:
+                    workflow_state["zip_path"] = f"{destination}/{workflow_state['skill_name']}.zip"
+
+            workflow_state["phases_completed"].append("package_skill")
+        else:
+            # Dry run - show expected package format
+            if target == "gemini":
+                pkg_ext = "tar.gz"
+                pkg_file = f"{destination}/{workflow_state['skill_name']}-gemini.tar.gz"
+            elif target == "openai":
+                pkg_ext = "zip"
+                pkg_file = f"{destination}/{workflow_state['skill_name']}-openai.zip"
+            else:
+                pkg_ext = "zip"
+                pkg_file = f"{destination}/{workflow_state['skill_name']}.zip"
+
+            output_lines.append(
+                f"  [DRY RUN] Would package to {pkg_ext} file for {adaptor.PLATFORM_NAME}"
+            )
+            workflow_state["zip_path"] = pkg_file
+
+        output_lines.append("")
+
+        # ===== PHASE 5: Upload (Optional) =====
+        if auto_upload:
+            phase_num = "5/5" if config_name else "4/4"
+            output_lines.append(f"📤 PHASE {phase_num}: Upload to {adaptor.PLATFORM_NAME}")
+            output_lines.append("-" * 70)
+            output_lines.append(f"Package file: {workflow_state['zip_path']}")
+            output_lines.append("")
+
+            # Check for platform-specific API key
+            env_var_name = adaptor.get_env_var_name()
+            has_api_key = os.environ.get(env_var_name, "").strip()
+
+            if not dry_run:
+                if has_api_key:
+                    # Upload not supported for markdown platform
+                    if target == "markdown":
+                        output_lines.append("⚠️  Markdown export does not support upload")
+                        output_lines.append("    Package has been created - use manually")
+                    else:
+                        # Call upload_skill_tool with target
+                        upload_result = await upload_skill_tool(
+                            {"skill_zip": workflow_state["zip_path"], "target": target}
+                        )
+
+                        upload_output = upload_result[0].text
+                        output_lines.append(upload_output)
+
+                        workflow_state["phases_completed"].append("upload_skill")
+                else:
+                    # Platform-specific instructions for missing API key
+                    output_lines.append(f"⚠️  {env_var_name} not set - skipping upload")
+                    output_lines.append("")
+                    output_lines.append("To enable automatic upload:")
+
+                    if target == "claude":
+                        output_lines.append("  1. Get API key from https://console.anthropic.com/")
+                        output_lines.append("  2. Set: export ANTHROPIC_API_KEY=sk-ant-...")
+                        output_lines.append("")
+                        output_lines.append("📤 Manual upload:")
+                        output_lines.append("  1. Go to https://claude.ai/skills")
+                        output_lines.append("  2. Click 'Upload Skill'")
+                        output_lines.append(f"  3. Select: {workflow_state['zip_path']}")
+                    elif target == "gemini":
+                        output_lines.append("  1. Get API key from https://aistudio.google.com/")
+                        output_lines.append("  2. Set: export GOOGLE_API_KEY=AIza...")
+                        output_lines.append("")
+                        output_lines.append("📤 Manual upload:")
+                        output_lines.append("  1. Go to https://aistudio.google.com/")
+                        output_lines.append(f"  2. Upload package: {workflow_state['zip_path']}")
+                    elif target == "openai":
+                        output_lines.append("  1. Get API key from https://platform.openai.com/")
+                        output_lines.append("  2. Set: export OPENAI_API_KEY=sk-proj-...")
+                        output_lines.append("")
+                        output_lines.append("📤 Manual upload:")
+                        output_lines.append("  1. Use OpenAI Assistants API")
+                        output_lines.append(f"  2. Upload package: {workflow_state['zip_path']}")
+                    elif target == "markdown":
+                        output_lines.append("  (No API key needed - markdown is export only)")
+                        output_lines.append(f"  Package created: {workflow_state['zip_path']}")
+            else:
+                output_lines.append(
+                    f"  [DRY RUN] Would upload to {adaptor.PLATFORM_NAME} (if API key set)"
+                )
+
+            output_lines.append("")
+
+        # ===== WORKFLOW SUMMARY =====
+        output_lines.append("=" * 70)
+        output_lines.append("✅ WORKFLOW COMPLETE")
+        output_lines.append("=" * 70)
+        output_lines.append("")
+
+        if not dry_run:
+            output_lines.append("Phases completed:")
+            for phase in workflow_state["phases_completed"]:
+                output_lines.append(f"  ✓ {phase}")
+            output_lines.append("")
+
+            output_lines.append("📁 Output:")
+            output_lines.append(f"  Skill directory: {workflow_state['skill_dir']}")
+            if workflow_state["zip_path"]:
+                output_lines.append(f"  Skill package: {workflow_state['zip_path']}")
+            output_lines.append("")
+
+            if auto_upload and has_api_key and target != "markdown":
+                # Platform-specific success message
+                if target == "claude":
+                    output_lines.append("🎉 Your skill is now available in Claude!")
+                    output_lines.append("   Go to https://claude.ai/skills to use it")
+                elif target == "gemini":
+                    output_lines.append("🎉 Your skill is now available in Gemini!")
+                    output_lines.append("   Go to https://aistudio.google.com/ to use it")
+                elif target == "openai":
+                    output_lines.append("🎉 Your assistant is now available in OpenAI!")
+                    output_lines.append(
+                        "   Go to https://platform.openai.com/assistants/ to use it"
+                    )
+            elif auto_upload:
+                output_lines.append("📝 Manual upload required (see instructions above)")
+            else:
+                output_lines.append("📤 To upload:")
+                output_lines.append(
+                    f"   skill-seekers upload {workflow_state['zip_path']} --target {target}"
+                )
+        else:
+            output_lines.append("This was a dry run. No actions were taken.")
+            output_lines.append("")
+            output_lines.append("To execute for real, remove the --dry-run flag:")
+            if config_name:
+                output_lines.append(f"  install_skill(config_name='{config_name}')")
+            else:
+                output_lines.append(f"  install_skill(config_path='{config_path}')")
+
+        return [TextContent(type="text", text="\n".join(output_lines))]
+
+    except Exception as e:
+        output_lines.append("")
+        output_lines.append(f"❌ Workflow failed: {str(e)}")
+        output_lines.append("")
+        output_lines.append("Phases completed before failure:")
+        for phase in workflow_state["phases_completed"]:
+            output_lines.append(f"  ✓ {phase}")
+        return [TextContent(type="text", text="\n".join(output_lines))]