CLI Adapter

# Repository settings
MAGPIE_REPO_DIR=/path/to/your/repo  # Default: current directory
MAGPIE_BASE_BRANCH=main             # Default: "main"
MAGPIE_GITHUB_ORG=your-org          # Optional: for org-scoped cloning

# CI commands
MAGPIE_TEST_CMD="cargo test"        # Default: "cargo test"
MAGPIE_LINT_CMD="cargo clippy"      # Default: "cargo clippy"
MAGPIE_MAX_CI_ROUNDS=2              # Default: 2

# Optional: Plane.so integration
PLANE_BASE_URL=https://your-plane.so
PLANE_API_KEY=your_api_key
PLANE_WORKSPACE_SLUG=your-workspace
PLANE_PROJECT_ID=your-project-id

# Optional: Daytona sandbox execution
DAYTONA_API_KEY=your_daytona_key
DAYTONA_BASE_URL=https://app.daytona.io/api
DAYTONA_ORGANIZATION_ID=your-org-id
DAYTONA_SANDBOX_CLASS=small         # Options: small, medium, large
DAYTONA_SNAPSHOT_NAME=myproject-snapshot

# Optional: Daytona environment variables (comma-separated KEY=VALUE pairs)
DAYTONA_ENV="NODE_ENV=production,DEBUG=false"

# Optional: Daytona volume mount
DAYTONA_VOLUME_ID=vol-abc123
DAYTONA_VOLUME_MOUNT_PATH=/workspace/data

fn build_pipeline_config(trace_enabled: bool) -> magpie_core::PipelineConfig {
    let plane = match (
        std::env::var("PLANE_BASE_URL"),
        std::env::var("PLANE_API_KEY"),
        std::env::var("PLANE_WORKSPACE_SLUG"),
        std::env::var("PLANE_PROJECT_ID"),
    ) {
        (Ok(base_url), Ok(api_key), Ok(workspace_slug), Ok(project_id)) => Some(PlaneConfig {
            base_url,
            api_key,
            workspace_slug,
            project_id,
        }),
        _ => None,
    };

    let repo_dir = std::env::var("MAGPIE_REPO_DIR")
        .map(PathBuf::from)
        .unwrap_or_else(|_| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));

    let trace_dir = if trace_enabled {
        Some(magpie_core::trace::default_trace_dir(&repo_dir))
    } else {
        None
    };

    PipelineConfig {
        repo_dir,
        base_branch: std::env::var("MAGPIE_BASE_BRANCH").unwrap_or_else(|_| "main".to_string()),
        test_command: std::env::var("MAGPIE_TEST_CMD").unwrap_or_else(|_| "cargo test".to_string()),
        lint_command: std::env::var("MAGPIE_LINT_CMD")
            .unwrap_or_else(|_| "cargo clippy".to_string()),
        max_ci_rounds: std::env::var("MAGPIE_MAX_CI_ROUNDS")
            .ok()
            .and_then(|v| v.parse().ok())
            .unwrap_or(2),
        plane,
        dry_run: false,
        github_org: std::env::var("MAGPIE_GITHUB_ORG").ok(),
        trace_dir,
        daytona: read_daytona_config(),
        #[cfg(feature = "daytona")]
        pool: None,
    }
}

name: Magpie Automated Fixes

on:
  issues:
    types: [labeled]

jobs:
  magpie:
    if: github.event.label.name == 'magpie'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Install Rust
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
      
      - name: Build Magpie
        run: cargo build --release -p magpie-cli
      
      - name: Run Magpie Pipeline
        env:
          MAGPIE_GITHUB_ORG: ${{ github.repository_owner }}
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          ./target/release/magpie-cli --trace --pipeline "${{ github.event.issue.title }}"

struct CliPlatform;

#[async_trait::async_trait]
impl magpie_core::ChatPlatform for CliPlatform {
    fn name(&self) -> &str {
        "cli"
    }

    async fn fetch_history(&self, _channel_id: &str) -> Result<String> {
        Ok(String::new())
    }

    async fn send_message(&self, _channel_id: &str, _text: &str) -> Result<()> {
        Ok(())
    }
}