automagik-forge 0.1.13 → 0.1.14

package/backend/src/bin/generate_types.rs

@@ -1,189 +0,0 @@
-use std::{env, fs, path::Path};
-
-use ts_rs::TS;
-// in [build-dependencies]
-
-fn generate_constants() -> String {
-    r#"// Generated constants
-export const EXECUTOR_TYPES: string[] = [
-    "echo",
-    "claude",
-    "claude-plan",
-    "amp",
-    "gemini",
-    "charm-opencode",
-    "claude-code-router",
-    "sst-opencode",
-    "opencode-ai"
-];
-
-export const EDITOR_TYPES: EditorType[] = [
-    "vscode",
-    "cursor", 
-    "windsurf",
-    "intellij",
-    "zed",
-    "custom"
-];
-
-export const EXECUTOR_LABELS: Record<string, string> = {
-    "echo": "Echo (Test Mode)",
-    "claude": "Claude Code",
-    "claude-plan": "Claude Code Plan",
-    "amp": "Amp",
-    "gemini": "Gemini",
-    "charm-opencode": "Charm Opencode",
-    "claude-code-router": "Claude Code Router",
-    "sst-opencode": "SST Opencode",
-    "opencode-ai": "OpenCode AI"
-};
-
-export const EDITOR_LABELS: Record<string, string> = {
-    "vscode": "VS Code",
-    "cursor": "Cursor",
-    "windsurf": "Windsurf",
-    "intellij": "IntelliJ IDEA",
-    "zed": "Zed",
-    "custom": "Custom"
-};
-
-export const SOUND_FILES: SoundFile[] = [
-    "abstract-sound1",
-    "abstract-sound2",
-    "abstract-sound3",
-    "abstract-sound4",
-    "cow-mooing",
-    "phone-vibration",
-    "rooster"
-];
-
-export const SOUND_LABELS: Record<string, string> = {
-    "abstract-sound1": "Gentle Chime",
-    "abstract-sound2": "Soft Bell",
-    "abstract-sound3": "Digital Tone",
-    "abstract-sound4": "Subtle Alert",
-    "cow-mooing": "Cow Mooing",
-    "phone-vibration": "Phone Vibration",
-    "rooster": "Rooster Call"
-};"#
-    .to_string()
-}
-
-fn generate_types_content() -> String {
-    // 4. Friendly banner
-    const HEADER: &str =
-        "// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs).\n\
-         // Do not edit this file manually.\n\
-         // Auto-generated from Rust backend types using ts-rs\n\n";
-
-    // 5. Add `export` if it’s missing, then join
-    let decls = [
-        automagik_forge::models::ApiResponse::<()>::decl(),
-        automagik_forge::models::config::Config::decl(),
-        automagik_forge::models::config::ThemeMode::decl(),
-        automagik_forge::models::config::EditorConfig::decl(),
-        automagik_forge::models::config::GitHubConfig::decl(),
-        automagik_forge::models::config::EditorType::decl(),
-        automagik_forge::models::config::EditorConstants::decl(),
-        automagik_forge::models::config::SoundFile::decl(),
-        automagik_forge::models::config::SoundConstants::decl(),
-        automagik_forge::routes::config::ConfigConstants::decl(),
-        automagik_forge::executor::ExecutorConfig::decl(),
-        automagik_forge::executor::ExecutorConstants::decl(),
-        automagik_forge::models::project::CreateProject::decl(),
-        automagik_forge::models::project::Project::decl(),
-        automagik_forge::models::project::ProjectWithBranch::decl(),
-        automagik_forge::models::project::UpdateProject::decl(),
-        automagik_forge::models::project::SearchResult::decl(),
-        automagik_forge::models::project::SearchMatchType::decl(),
-        automagik_forge::models::project::GitBranch::decl(),
-        automagik_forge::models::project::CreateBranch::decl(),
-        automagik_forge::models::task::CreateTask::decl(),
-        automagik_forge::models::task::CreateTaskAndStart::decl(),
-        automagik_forge::models::task::TaskStatus::decl(),
-        automagik_forge::models::task::Task::decl(),
-        automagik_forge::models::task::TaskWithAttemptStatus::decl(),
-        automagik_forge::models::task::UpdateTask::decl(),
-        automagik_forge::models::task_template::TaskTemplate::decl(),
-        automagik_forge::models::task_template::CreateTaskTemplate::decl(),
-        automagik_forge::models::task_template::UpdateTaskTemplate::decl(),
-        automagik_forge::models::task_attempt::TaskAttemptStatus::decl(),
-        automagik_forge::models::task_attempt::TaskAttempt::decl(),
-        automagik_forge::models::task_attempt::CreateTaskAttempt::decl(),
-        automagik_forge::models::task_attempt::UpdateTaskAttempt::decl(),
-        automagik_forge::models::task_attempt::CreateFollowUpAttempt::decl(),
-        automagik_forge::routes::filesystem::DirectoryEntry::decl(),
-        automagik_forge::routes::filesystem::DirectoryListResponse::decl(),
-        automagik_forge::routes::auth::DeviceStartResponse::decl(),
-        automagik_forge::routes::task_attempts::ProcessLogsResponse::decl(),
-        automagik_forge::models::task_attempt::DiffChunkType::decl(),
-        automagik_forge::models::task_attempt::DiffChunk::decl(),
-        automagik_forge::models::task_attempt::FileDiff::decl(),
-        automagik_forge::models::task_attempt::WorktreeDiff::decl(),
-        automagik_forge::models::task_attempt::BranchStatus::decl(),
-        automagik_forge::models::task_attempt::ExecutionState::decl(),
-        automagik_forge::models::task_attempt::TaskAttemptState::decl(),
-        automagik_forge::models::execution_process::ExecutionProcess::decl(),
-        automagik_forge::models::execution_process::ExecutionProcessSummary::decl(),
-        automagik_forge::models::execution_process::ExecutionProcessStatus::decl(),
-        automagik_forge::models::execution_process::ExecutionProcessType::decl(),
-        automagik_forge::models::execution_process::CreateExecutionProcess::decl(),
-        automagik_forge::models::execution_process::UpdateExecutionProcess::decl(),
-        automagik_forge::models::executor_session::ExecutorSession::decl(),
-        automagik_forge::models::executor_session::CreateExecutorSession::decl(),
-        automagik_forge::models::executor_session::UpdateExecutorSession::decl(),
-        automagik_forge::executor::NormalizedConversation::decl(),
-        automagik_forge::executor::NormalizedEntry::decl(),
-        automagik_forge::executor::NormalizedEntryType::decl(),
-        automagik_forge::executor::ActionType::decl(),
-    ];
-
-    let body = decls
-        .into_iter()
-        .map(|d| {
-            let trimmed = d.trim_start();
-            if trimmed.starts_with("export") {
-                d
-            } else {
-                format!("export {trimmed}")
-            }
-        })
-        .collect::<Vec<_>>()
-        .join("\n\n");
-
-    let constants = generate_constants();
-    format!("{HEADER}{body}\n\n{constants}")
-}
-
-fn main() {
-    let args: Vec<String> = env::args().collect();
-    let check_mode = args.iter().any(|arg| arg == "--check");
-
-    // 1. Make sure ../shared exists
-    let shared_path = Path::new("../shared");
-    fs::create_dir_all(shared_path).expect("cannot create ../shared");
-
-    println!("Generating TypeScript types…");
-
-    // 2. Let ts-rs write its per-type files here (handy for debugging)
-    env::set_var("TS_RS_EXPORT_DIR", shared_path.to_str().unwrap());
-
-    let generated = generate_types_content();
-    let types_path = shared_path.join("types.ts");
-
-    if check_mode {
-        // Read the current file
-        let current = fs::read_to_string(&types_path).unwrap_or_default();
-        if current == generated {
-            println!("✅ shared/types.ts is up to date.");
-            std::process::exit(0);
-        } else {
-            eprintln!("❌ shared/types.ts is not up to date. Please run 'npm run generate-types' and commit the changes.");
-            std::process::exit(1);
-        }
-    } else {
-        // Write the file as before
-        fs::write(&types_path, generated).expect("unable to write types.ts");
-        println!("✅ TypeScript types generated in ../shared/");
-    }
-}

package/backend/src/bin/mcp_task_server.rs

@@ -1,191 +0,0 @@
-use std::{net::SocketAddr, str::FromStr, sync::Arc};
-
-use rmcp::{transport::{stdio, sse_server::SseServer}, ServiceExt};
-use sqlx::{sqlite::SqliteConnectOptions, SqlitePool};
-use tokio_util::sync::CancellationToken;
-use tracing_subscriber::{prelude::*, EnvFilter};
-use automagik_forge::{mcp::task_server::TaskServer, sentry_layer, utils::asset_dir};
-
-fn main() -> anyhow::Result<()> {
-    // Load .env file if it exists
-    dotenvy::dotenv().ok();
-    
-    // Parse command line arguments
-    let args: Vec<String> = std::env::args().collect();
-    let enable_sse = args.contains(&"--mcp-sse".to_string());
-    let enable_stdio = args.contains(&"--mcp".to_string()) || enable_sse;
-    
-    let (stdio_mode, sse_mode) = if enable_sse {
-        (enable_stdio, true)   // STDIO if --mcp flag present, SSE always
-    } else {
-        (enable_stdio, true)   // STDIO only if --mcp flag, SSE by default
-    };
-
-    let environment = if cfg!(debug_assertions) {
-        "dev"
-    } else {
-        "production"
-    };
-    // Check if telemetry is disabled
-    let telemetry_disabled = std::env::var("DISABLE_TELEMETRY")
-        .unwrap_or_default()
-        .to_lowercase() == "true";
-    
-    let _guard = if !telemetry_disabled {
-        let sentry_dsn = std::env::var("SENTRY_DSN")
-            .unwrap_or_else(|_| "https://fa5e961d24021da4e6df30e5beee03af@o4509714066571264.ingest.us.sentry.io/4509714113495040".to_string());
-        
-        Some(sentry::init((sentry_dsn, sentry::ClientOptions {
-            release: sentry::release_name!(),
-            environment: Some(environment.into()),
-            ..Default::default()
-        })))
-    } else {
-        None
-    };
-    sentry::configure_scope(|scope| {
-        scope.set_tag("source", "mcp");
-    });
-    tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()
-        .unwrap()
-        .block_on(async {
-            tracing_subscriber::registry()
-                .with(
-                    tracing_subscriber::fmt::layer()
-                        .with_writer(std::io::stderr)
-                        .with_filter(
-                            std::env::var("RUST_LOG")
-                                .map(|level| EnvFilter::new(level))
-                                .unwrap_or_else(|_| EnvFilter::new("info"))
-                        ),
-                )
-                .with(sentry_layer())
-                .init();
-
-            tracing::debug!("[MCP] Starting MCP task server...");
-
-            // Database connection
-            let database_url = format!(
-                "sqlite://{}",
-                asset_dir().join("db.sqlite").to_string_lossy()
-            );
-
-            let options = SqliteConnectOptions::from_str(&database_url)?.create_if_missing(false);
-            let pool = SqlitePool::connect_with(options).await?;
-
-            let task_server = TaskServer::new(pool);
-            let service = Arc::new(task_server);
-            
-            let mut join_set = tokio::task::JoinSet::new();
-            let shutdown_token = CancellationToken::new();
-            
-            // Start STDIO transport if requested
-            if stdio_mode {
-                let service_clone = service.clone();
-                let token = shutdown_token.clone();
-                join_set.spawn(async move {
-                    tokio::select! {
-                        result = run_stdio_server(service_clone) => {
-                            tracing::info!("STDIO server completed: {:?}", result);
-                            result
-                        }
-                        _ = token.cancelled() => {
-                            tracing::info!("STDIO server cancelled");
-                            Ok(())
-                        }
-                    }
-                });
-            }
-            
-            // Start SSE transport if requested
-            if sse_mode {
-                let service_clone = service.clone();
-                let token = shutdown_token.clone();
-                let sse_port = get_sse_port();
-                join_set.spawn(async move {
-                    tokio::select! {
-                        result = run_sse_server(service_clone, sse_port) => {
-                            tracing::info!("SSE server completed: {:?}", result);
-                            result
-                        }
-                        _ = token.cancelled() => {
-                            tracing::info!("SSE server cancelled");
-                            Ok(())
-                        }
-                    }
-                });
-            }
-            
-            // Wait for shutdown signal or any service to fail
-            tokio::select! {
-                _ = tokio::signal::ctrl_c() => {
-                    tracing::info!("Received Ctrl+C, shutting down...");
-                }
-                Some(result) = join_set.join_next() => {
-                    if let Err(e) = result {
-                        tracing::error!("Service task failed: {:?}", e);
-                    }
-                }
-            }
-            
-            // Trigger shutdown for all services
-            shutdown_token.cancel();
-            
-            // Wait for all tasks to complete with timeout
-            let shutdown_timeout = tokio::time::Duration::from_secs(5);
-            tokio::time::timeout(shutdown_timeout, async {
-                while let Some(_) = join_set.join_next().await {}
-            }).await.ok();
-            
-            tracing::info!("MCP server shutdown complete");
-            Ok(())
-        })
-}
-
-async fn run_stdio_server(service: Arc<TaskServer>) -> anyhow::Result<()> {
-    tracing::info!("Starting MCP STDIO server...");
-    let server = service.as_ref().clone().serve(stdio()).await
-        .inspect_err(|e| {
-            tracing::error!("STDIO serving error: {:?}", e);
-            sentry::capture_error(e);
-        })?;
-    
-    server.waiting().await?;
-    Ok(())
-}
-
-async fn run_sse_server(service: Arc<TaskServer>, port: u16) -> anyhow::Result<()> {
-    let bind_addr = SocketAddr::from(([0, 0, 0, 0], port));
-    
-    match SseServer::serve(bind_addr).await {
-        Ok(sse_server) => {
-            tracing::info!("MCP SSE server listening on http://{}/sse", bind_addr);
-            
-            let cancellation_token = sse_server.with_service({
-                let service = service.clone();
-                move || service.as_ref().clone()
-            });
-            cancellation_token.cancelled().await;
-            Ok(())
-        }
-        Err(e) => {
-            tracing::error!("Failed to start SSE server on port {}: {}", port, e);
-            // Don't fail the entire application if SSE fails
-            if std::env::var("MCP_SSE_REQUIRED").is_ok() {
-                Err(e.into())
-            } else {
-                tracing::warn!("SSE server disabled due to startup failure");
-                Ok(())
-            }
-        }
-    }
-}
-
-fn get_sse_port() -> u16 {
-    std::env::var("MCP_SSE_PORT")
-        .ok()
-        .and_then(|s| s.parse().ok())
-        .unwrap_or(8765) // Default fallback port
-}