automagik-forge 0.1.13 → 0.1.14

package/backend/src/services/github_service.rs

@@ -1,307 +0,0 @@
-use std::time::Duration;
-
-use octocrab::{Octocrab, OctocrabBuilder};
-use serde::{Deserialize, Serialize};
-use tokio::time::sleep;
-use tracing::{info, warn};
-
-#[derive(Debug)]
-pub enum GitHubServiceError {
-    Client(octocrab::Error),
-    Auth(String),
-    Repository(String),
-    PullRequest(String),
-    Branch(String),
-    TokenInvalid,
-}
-
-impl std::fmt::Display for GitHubServiceError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            GitHubServiceError::Client(e) => write!(f, "GitHub client error: {}", e),
-            GitHubServiceError::Auth(e) => write!(f, "Authentication error: {}", e),
-            GitHubServiceError::Repository(e) => write!(f, "Repository error: {}", e),
-            GitHubServiceError::PullRequest(e) => write!(f, "Pull request error: {}", e),
-            GitHubServiceError::Branch(e) => write!(f, "Branch error: {}", e),
-            GitHubServiceError::TokenInvalid => write!(f, "GitHub token is invalid or expired."),
-        }
-    }
-}
-
-impl std::error::Error for GitHubServiceError {}
-
-impl From<octocrab::Error> for GitHubServiceError {
-    fn from(err: octocrab::Error) -> Self {
-        match &err {
-            octocrab::Error::GitHub { source, .. } => {
-                let status = source.status_code.as_u16();
-                let msg = source.message.to_ascii_lowercase();
-                if status == 401
-                    || status == 403
-                    || msg.contains("bad credentials")
-                    || msg.contains("token expired")
-                {
-                    GitHubServiceError::TokenInvalid
-                } else {
-                    GitHubServiceError::Client(err)
-                }
-            }
-            _ => GitHubServiceError::Client(err),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct GitHubRepoInfo {
-    pub owner: String,
-    pub repo_name: String,
-}
-
-#[derive(Debug, Clone)]
-pub struct CreatePrRequest {
-    pub title: String,
-    pub body: Option<String>,
-    pub head_branch: String,
-    pub base_branch: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PullRequestInfo {
-    pub number: i64,
-    pub url: String,
-    pub status: String,
-    pub merged: bool,
-    pub merged_at: Option<chrono::DateTime<chrono::Utc>>,
-    pub merge_commit_sha: Option<String>,
-}
-
-#[derive(Debug, Clone)]
-pub struct GitHubService {
-    client: Octocrab,
-    retry_config: RetryConfig,
-}
-
-#[derive(Debug, Clone)]
-pub struct RetryConfig {
-    pub max_retries: u32,
-    pub base_delay: Duration,
-    pub max_delay: Duration,
-}
-
-impl Default for RetryConfig {
-    fn default() -> Self {
-        Self {
-            max_retries: 3,
-            base_delay: Duration::from_secs(1),
-            max_delay: Duration::from_secs(30),
-        }
-    }
-}
-
-impl GitHubService {
-    /// Create a new GitHub service with authentication
-    pub fn new(github_token: &str) -> Result<Self, GitHubServiceError> {
-        let client = OctocrabBuilder::new()
-            .personal_token(github_token.to_string())
-            .build()
-            .map_err(|e| {
-                GitHubServiceError::Auth(format!("Failed to create GitHub client: {}", e))
-            })?;
-
-        Ok(Self {
-            client,
-            retry_config: RetryConfig::default(),
-        })
-    }
-
-    /// Create a pull request on GitHub
-    pub async fn create_pr(
-        &self,
-        repo_info: &GitHubRepoInfo,
-        request: &CreatePrRequest,
-    ) -> Result<PullRequestInfo, GitHubServiceError> {
-        self.with_retry(|| async { self.create_pr_internal(repo_info, request).await })
-            .await
-    }
-
-    async fn create_pr_internal(
-        &self,
-        repo_info: &GitHubRepoInfo,
-        request: &CreatePrRequest,
-    ) -> Result<PullRequestInfo, GitHubServiceError> {
-        // Verify repository access
-        self.client
-            .repos(&repo_info.owner, &repo_info.repo_name)
-            .get()
-            .await
-            .map_err(|e| {
-                GitHubServiceError::Repository(format!(
-                    "Cannot access repository {}/{}: {}",
-                    repo_info.owner, repo_info.repo_name, e
-                ))
-            })?;
-
-        // Check if the base branch exists
-        self.client
-            .repos(&repo_info.owner, &repo_info.repo_name)
-            .get_ref(&octocrab::params::repos::Reference::Branch(
-                request.base_branch.clone(),
-            ))
-            .await
-            .map_err(|e| {
-                GitHubServiceError::Branch(format!(
-                    "Base branch '{}' does not exist: {}",
-                    request.base_branch, e
-                ))
-            })?;
-
-        // Check if the head branch exists
-        self.client
-            .repos(&repo_info.owner, &repo_info.repo_name)
-            .get_ref(&octocrab::params::repos::Reference::Branch(
-                request.head_branch.clone(),
-            ))
-            .await
-            .map_err(|e| {
-                GitHubServiceError::Branch(format!(
-                    "Head branch '{}' does not exist. Make sure the branch was pushed successfully: {}",
-                    request.head_branch, e
-                ))
-            })?;
-
-        // Create the pull request
-        let pr = self
-            .client
-            .pulls(&repo_info.owner, &repo_info.repo_name)
-            .create(&request.title, &request.head_branch, &request.base_branch)
-            .body(request.body.as_deref().unwrap_or(""))
-            .send()
-            .await
-            .map_err(|e| match e {
-                octocrab::Error::GitHub { source, .. } => {
-                    if source.status_code.as_u16() == 401
-                        || source.status_code.as_u16() == 403
-                        || source
-                            .message
-                            .to_ascii_lowercase()
-                            .contains("bad credentials")
-                        || source
-                            .message
-                            .to_ascii_lowercase()
-                            .contains("token expired")
-                    {
-                        GitHubServiceError::TokenInvalid
-                    } else {
-                        GitHubServiceError::PullRequest(format!(
-                            "GitHub API error: {} (status: {})",
-                            source.message,
-                            source.status_code.as_u16()
-                        ))
-                    }
-                }
-                _ => GitHubServiceError::PullRequest(format!("Failed to create PR: {}", e)),
-            })?;
-
-        let pr_info = PullRequestInfo {
-            number: pr.number as i64,
-            url: pr.html_url.map(|url| url.to_string()).unwrap_or_default(),
-            status: "open".to_string(),
-            merged: false,
-            merged_at: None,
-            merge_commit_sha: None,
-        };
-
-        info!(
-            "Created GitHub PR #{} for branch {} in {}/{}",
-            pr_info.number, request.head_branch, repo_info.owner, repo_info.repo_name
-        );
-
-        Ok(pr_info)
-    }
-
-    /// Update and get the status of a pull request
-    pub async fn update_pr_status(
-        &self,
-        repo_info: &GitHubRepoInfo,
-        pr_number: i64,
-    ) -> Result<PullRequestInfo, GitHubServiceError> {
-        self.with_retry(|| async { self.update_pr_status_internal(repo_info, pr_number).await })
-            .await
-    }
-
-    async fn update_pr_status_internal(
-        &self,
-        repo_info: &GitHubRepoInfo,
-        pr_number: i64,
-    ) -> Result<PullRequestInfo, GitHubServiceError> {
-        let pr = self
-            .client
-            .pulls(&repo_info.owner, &repo_info.repo_name)
-            .get(pr_number as u64)
-            .await
-            .map_err(|e| {
-                GitHubServiceError::PullRequest(format!("Failed to get PR #{}: {}", pr_number, e))
-            })?;
-
-        let status = match pr.state {
-            Some(octocrab::models::IssueState::Open) => "open",
-            Some(octocrab::models::IssueState::Closed) => {
-                if pr.merged_at.is_some() {
-                    "merged"
-                } else {
-                    "closed"
-                }
-            }
-            None => "unknown",
-            Some(_) => "unknown", // Handle any other states
-        };
-
-        let pr_info = PullRequestInfo {
-            number: pr.number as i64,
-            url: pr.html_url.map(|url| url.to_string()).unwrap_or_default(),
-            status: status.to_string(),
-            merged: pr.merged_at.is_some(),
-            merged_at: pr.merged_at.map(|dt| dt.naive_utc().and_utc()),
-            merge_commit_sha: pr.merge_commit_sha.clone(),
-        };
-
-        Ok(pr_info)
-    }
-
-    /// Retry wrapper for GitHub API calls with exponential backoff
-    async fn with_retry<F, Fut, T>(&self, operation: F) -> Result<T, GitHubServiceError>
-    where
-        F: Fn() -> Fut,
-        Fut: std::future::Future<Output = Result<T, GitHubServiceError>>,
-    {
-        let mut last_error = None;
-
-        for attempt in 0..=self.retry_config.max_retries {
-            match operation().await {
-                Ok(result) => return Ok(result),
-                Err(e) => {
-                    last_error = Some(e);
-
-                    if attempt < self.retry_config.max_retries {
-                        let delay = std::cmp::min(
-                            self.retry_config.base_delay * 2_u32.pow(attempt),
-                            self.retry_config.max_delay,
-                        );
-
-                        warn!(
-                            "GitHub API call failed (attempt {}/{}), retrying in {:?}: {}",
-                            attempt + 1,
-                            self.retry_config.max_retries + 1,
-                            delay,
-                            last_error.as_ref().unwrap()
-                        );
-
-                        sleep(delay).await;
-                    }
-                }
-            }
-        }
-
-        Err(last_error.unwrap())
-    }
-}

package/backend/src/services/mod.rs

@@ -1,13 +0,0 @@
-pub mod analytics;
-pub mod git_service;
-pub mod github_service;
-pub mod notification_service;
-pub mod pr_monitor;
-pub mod process_service;
-
-pub use analytics::{generate_user_id, AnalyticsConfig, AnalyticsService};
-pub use git_service::{GitService, GitServiceError};
-pub use github_service::{CreatePrRequest, GitHubRepoInfo, GitHubService, GitHubServiceError};
-pub use notification_service::{NotificationConfig, NotificationService};
-pub use pr_monitor::PrMonitorService;
-pub use process_service::ProcessService;

package/backend/src/services/notification_service.rs

@@ -1,263 +0,0 @@
-use std::sync::OnceLock;
-
-use crate::models::config::SoundFile;
-
-/// Service for handling cross-platform notifications including sound alerts and push notifications
-#[derive(Debug, Clone)]
-pub struct NotificationService {
-    sound_enabled: bool,
-    push_enabled: bool,
-}
-
-/// Configuration for notifications
-#[derive(Debug, Clone)]
-pub struct NotificationConfig {
-    pub sound_enabled: bool,
-    pub push_enabled: bool,
-}
-
-impl Default for NotificationConfig {
-    fn default() -> Self {
-        Self {
-            sound_enabled: true,
-            push_enabled: true,
-        }
-    }
-}
-
-/// Cache for WSL root path from PowerShell
-static WSL_ROOT_PATH_CACHE: OnceLock<Option<String>> = OnceLock::new();
-
-impl NotificationService {
-    /// Create a new NotificationService with the given configuration
-    pub fn new(config: NotificationConfig) -> Self {
-        Self {
-            sound_enabled: config.sound_enabled,
-            push_enabled: config.push_enabled,
-        }
-    }
-
-    /// Send both sound and push notifications if enabled
-    pub async fn notify(&self, title: &str, message: &str, sound_file: &SoundFile) {
-        if self.sound_enabled {
-            self.play_sound_notification(sound_file).await;
-        }
-
-        if self.push_enabled {
-            self.send_push_notification(title, message).await;
-        }
-    }
-
-    /// Play a system sound notification across platforms
-    pub async fn play_sound_notification(&self, sound_file: &SoundFile) {
-        if !self.sound_enabled {
-            return;
-        }
-
-        let file_path = match sound_file.get_path().await {
-            Ok(path) => path,
-            Err(e) => {
-                tracing::error!("Failed to create cached sound file: {}", e);
-                return;
-            }
-        };
-
-        // Use platform-specific sound notification
-        // Note: spawn() calls are intentionally not awaited - sound notifications should be fire-and-forget
-        if cfg!(target_os = "macos") {
-            let _ = tokio::process::Command::new("afplay")
-                .arg(&file_path)
-                .spawn();
-        } else if cfg!(target_os = "linux") && !crate::utils::is_wsl2() {
-            // Try different Linux audio players
-            if tokio::process::Command::new("paplay")
-                .arg(&file_path)
-                .spawn()
-                .is_ok()
-            {
-                // Success with paplay
-            } else if tokio::process::Command::new("aplay")
-                .arg(&file_path)
-                .spawn()
-                .is_ok()
-            {
-                // Success with aplay
-            } else {
-                // Try system bell as fallback
-                let _ = tokio::process::Command::new("echo")
-                    .arg("-e")
-                    .arg("\\a")
-                    .spawn();
-            }
-        } else if cfg!(target_os = "windows")
-            || (cfg!(target_os = "linux") && crate::utils::is_wsl2())
-        {
-            // Convert WSL path to Windows path if in WSL2
-            let file_path = if crate::utils::is_wsl2() {
-                if let Some(windows_path) = Self::wsl_to_windows_path(&file_path).await {
-                    windows_path
-                } else {
-                    file_path.to_string_lossy().to_string()
-                }
-            } else {
-                file_path.to_string_lossy().to_string()
-            };
-
-            let _ = tokio::process::Command::new("powershell.exe")
-                .arg("-c")
-                .arg(format!(
-                    r#"(New-Object Media.SoundPlayer "{}").PlaySync()"#,
-                    file_path
-                ))
-                .spawn();
-        }
-    }
-
-    /// Send a cross-platform push notification
-    pub async fn send_push_notification(&self, title: &str, message: &str) {
-        if !self.push_enabled {
-            return;
-        }
-
-        if cfg!(target_os = "macos") {
-            self.send_macos_notification(title, message).await;
-        } else if cfg!(target_os = "linux") && !crate::utils::is_wsl2() {
-            self.send_linux_notification(title, message).await;
-        } else if cfg!(target_os = "windows")
-            || (cfg!(target_os = "linux") && crate::utils::is_wsl2())
-        {
-            self.send_windows_notification(title, message).await;
-        }
-    }
-
-    /// Send macOS notification using osascript
-    async fn send_macos_notification(&self, title: &str, message: &str) {
-        let script = format!(
-            r#"display notification "{message}" with title "{title}" sound name "Glass""#,
-            message = message.replace('"', r#"\""#),
-            title = title.replace('"', r#"\""#)
-        );
-
-        let _ = tokio::process::Command::new("osascript")
-            .arg("-e")
-            .arg(script)
-            .spawn();
-    }
-
-    /// Send Linux notification using notify-rust
-    async fn send_linux_notification(&self, title: &str, message: &str) {
-        use notify_rust::Notification;
-
-        let title = title.to_string();
-        let message = message.to_string();
-
-        let _handle = tokio::task::spawn_blocking(move || {
-            if let Err(e) = Notification::new()
-                .summary(&title)
-                .body(&message)
-                .timeout(10000)
-                .show()
-            {
-                tracing::error!("Failed to send Linux notification: {}", e);
-            }
-        });
-        drop(_handle); // Don't await, fire-and-forget
-    }
-
-    /// Send Windows/WSL notification using PowerShell toast script
-    async fn send_windows_notification(&self, title: &str, message: &str) {
-        let script_path = match crate::utils::get_powershell_script().await {
-            Ok(path) => path,
-            Err(e) => {
-                tracing::error!("Failed to get PowerShell script: {}", e);
-                return;
-            }
-        };
-
-        // Convert WSL path to Windows path if in WSL2
-        let script_path_str = if crate::utils::is_wsl2() {
-            if let Some(windows_path) = Self::wsl_to_windows_path(&script_path).await {
-                windows_path
-            } else {
-                script_path.to_string_lossy().to_string()
-            }
-        } else {
-            script_path.to_string_lossy().to_string()
-        };
-
-        let _ = tokio::process::Command::new("powershell.exe")
-            .arg("-NoProfile")
-            .arg("-ExecutionPolicy")
-            .arg("Bypass")
-            .arg("-File")
-            .arg(script_path_str)
-            .arg("-Title")
-            .arg(title)
-            .arg("-Message")
-            .arg(message)
-            .spawn();
-    }
-
-    /// Get WSL root path via PowerShell (cached)
-    async fn get_wsl_root_path() -> Option<String> {
-        if let Some(cached) = WSL_ROOT_PATH_CACHE.get() {
-            return cached.clone();
-        }
-
-        match tokio::process::Command::new("powershell.exe")
-            .arg("-c")
-            .arg("(Get-Location).Path -replace '^.*::', ''")
-            .current_dir("/")
-            .output()
-            .await
-        {
-            Ok(output) => {
-                match String::from_utf8(output.stdout) {
-                    Ok(pwd_str) => {
-                        let pwd = pwd_str.trim();
-                        tracing::info!("WSL root path detected: {}", pwd);
-
-                        // Cache the result
-                        let _ = WSL_ROOT_PATH_CACHE.set(Some(pwd.to_string()));
-                        return Some(pwd.to_string());
-                    }
-                    Err(e) => {
-                        tracing::error!("Failed to parse PowerShell pwd output as UTF-8: {}", e);
-                    }
-                }
-            }
-            Err(e) => {
-                tracing::error!("Failed to execute PowerShell pwd command: {}", e);
-            }
-        }
-
-        // Cache the failure result
-        let _ = WSL_ROOT_PATH_CACHE.set(None);
-        None
-    }
-
-    /// Convert WSL path to Windows UNC path for PowerShell
-    async fn wsl_to_windows_path(wsl_path: &std::path::Path) -> Option<String> {
-        let path_str = wsl_path.to_string_lossy();
-
-        // Relative paths work fine as-is in PowerShell
-        if !path_str.starts_with('/') {
-            tracing::debug!("Using relative path as-is: {}", path_str);
-            return Some(path_str.to_string());
-        }
-
-        // Get cached WSL root path from PowerShell
-        if let Some(wsl_root) = Self::get_wsl_root_path().await {
-            // Simply concatenate WSL root with the absolute path - PowerShell doesn't mind /
-            let windows_path = format!("{}{}", wsl_root, path_str);
-            tracing::debug!("WSL path converted: {} -> {}", path_str, windows_path);
-            Some(windows_path)
-        } else {
-            tracing::error!(
-                "Failed to determine WSL root path for conversion: {}",
-                path_str
-            );
-            None
-        }
-    }
-}