Discord Adapter

# Required: Discord bot token from the Developer Portal
DISCORD_TOKEN=your_discord_bot_token_here

# Repository configuration
MAGPIE_REPO_DIR=/path/to/your/repo
MAGPIE_BASE_BRANCH=main
MAGPIE_GITHUB_ORG=your-org  # Optional: for org-scoped repo cloning

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

# Optional: Plane.so issue tracking
PLANE_BASE_URL=https://your-plane.so
PLANE_API_KEY=your_plane_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

async fn close_thread(&self, channel_id: &str) -> Result<()> {
    let id: u64 = channel_id.parse().context("invalid discord channel ID")?;
    let channel = ChannelId::new(id);

    channel
        .edit_thread(&self.http, EditThread::new().archived(true).locked(true))
        .await
        .context("failed to archive discord thread")?;

    Ok(())
}

let reply_channel = match msg
    .channel_id
    .create_thread_from_message(
        &ctx.http,
        msg.id,
        CreateThread::new(&thread_name)
            .auto_archive_duration(AutoArchiveDuration::OneDay)
            .kind(ChannelType::PublicThread),
    )
    .await
{
    Ok(thread) => {
        info!(thread_id = %thread.id, "created thread: {thread_name}");
        thread.id
    }
    Err(e) => {
        warn!("failed to create thread, falling back to channel: {e}");
        msg.channel_id
    }
};

pub fn strip_mention(content: &str, bot_id: u64) -> String {
    let mention_patterns = [format!("<@{bot_id}>"), format!("<@!{bot_id}>")];

    let mut result = content.to_string();
    for pattern in &mention_patterns {
        result = result.replace(pattern, "");
    }
    result.trim().to_string()
}

[Unit]
Description=Magpie Discord Bot
After=network.target

[Service]
Type=simple
User=magpie
WorkingDirectory=/opt/magpie
EnvironmentFile=/opt/magpie/.env
ExecStart=/opt/magpie/magpie-discord
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

version: '3.8'

services:
  magpie-discord:
    build:
      context: .
      dockerfile: Dockerfile.discord
    environment:
      - DISCORD_TOKEN=${DISCORD_TOKEN}
      - MAGPIE_REPO_DIR=/workspace
      - MAGPIE_BASE_BRANCH=main
      - MAGPIE_GITHUB_ORG=${GITHUB_ORG}
      - RUST_LOG=info
    volumes:
      - ./workspace:/workspace
      - ~/.gitconfig:/root/.gitconfig:ro
      - ~/.ssh:/root/.ssh:ro
    restart: unless-stopped

apiVersion: apps/v1
kind: Deployment
metadata:
  name: magpie-discord
spec:
  replicas: 1
  selector:
    matchLabels:
      app: magpie-discord
  template:
    metadata:
      labels:
        app: magpie-discord
    spec:
      containers:
      - name: magpie
        image: your-registry/magpie-discord:latest
        envFrom:
        - secretRef:
            name: magpie-discord-secrets
        - configMapRef:
            name: magpie-config
        volumeMounts:
        - name: workspace
          mountPath: /workspace
        - name: ssh-keys
          mountPath: /root/.ssh
          readOnly: true
      volumes:
      - name: workspace
        persistentVolumeClaim:
          claimName: magpie-workspace
      - name: ssh-keys
        secret:
          secretName: git-ssh-keys
          defaultMode: 0600
---
apiVersion: v1
kind: Secret
metadata:
  name: magpie-discord-secrets
type: Opaque
stringData:
  DISCORD_TOKEN: "your_token_here"
  DAYTONA_API_KEY: "your_daytona_key"

#[async_trait]
impl ChatPlatform for DiscordPlatform {
    fn name(&self) -> &str {
        "discord"
    }

    async fn fetch_history(&self, _channel_id: &str) -> Result<String> {
        // The trigger message itself is already passed as `task` in run_pipeline;
        // dumping the last N channel messages added noise rather than useful context.
        Ok(String::new())
    }

    async fn send_message(&self, channel_id: &str, text: &str) -> Result<()> {
        let id: u64 = channel_id.parse().context("invalid discord channel ID")?;
        let channel = ChannelId::new(id);

        channel
            .say(&self.http, text)
            .await
            .context("failed to send discord message")?;

        Ok(())
    }

    async fn close_thread(&self, channel_id: &str) -> Result<()> {
        let id: u64 = channel_id.parse().context("invalid discord channel ID")?;
        let channel = ChannelId::new(id);

        channel
            .edit_thread(&self.http, EditThread::new().archived(true).locked(true))
            .await
            .context("failed to archive discord thread")?;

        Ok()
    }
}