automagik-forge 0.1.11 → 0.1.13

package/backend/migrations/20250716161432_update_executor_names_to_kebab_case.sql

@@ -0,0 +1,20 @@
+-- Migration to update executor type names from snake_case/camelCase to kebab-case
+-- This handles the change from charmopencode -> charm-opencode and setup_script -> setup-script
+
+-- Update task_attempts.executor column
+UPDATE task_attempts 
+SET executor = 'charm-opencode' 
+WHERE executor = 'charmopencode';
+
+UPDATE task_attempts 
+SET executor = 'setup-script' 
+WHERE executor = 'setup_script';
+
+-- Update execution_processes.executor_type column
+UPDATE execution_processes 
+SET executor_type = 'charm-opencode' 
+WHERE executor_type = 'charmopencode';
+
+UPDATE execution_processes 
+SET executor_type = 'setup-script' 
+WHERE executor_type = 'setup_script';

package/backend/migrations/20250716170000_add_parent_task_to_tasks.sql

@@ -0,0 +1,7 @@
+PRAGMA foreign_keys = ON;
+
+-- Add parent_task_attempt column to tasks table
+ALTER TABLE tasks ADD COLUMN parent_task_attempt BLOB REFERENCES task_attempts(id);
+
+-- Create index for parent_task_attempt lookups
+CREATE INDEX idx_tasks_parent_task_attempt ON tasks(parent_task_attempt);

package/backend/migrations/20250717000000_drop_task_attempt_activities.sql

@@ -0,0 +1,9 @@
+-- Migration to drop task_attempt_activities table
+-- This removes the task attempt activity tracking functionality
+
+-- Drop indexes first
+DROP INDEX IF EXISTS idx_task_attempt_activities_execution_process_id;
+DROP INDEX IF EXISTS idx_task_attempt_activities_created_at;
+
+-- Drop the table
+DROP TABLE IF EXISTS task_attempt_activities;

package/backend/migrations/20250719000000_add_cleanup_script_to_projects.sql

@@ -0,0 +1,2 @@
+-- Add cleanup_script column to projects table
+ALTER TABLE projects ADD COLUMN cleanup_script TEXT;

package/backend/migrations/20250720000000_add_cleanupscript_to_process_type_constraint.sql

@@ -0,0 +1,25 @@
+-- 1. Add the replacement column with the wider CHECK
+ALTER TABLE execution_processes
+  ADD COLUMN process_type_new TEXT NOT NULL DEFAULT 'setupscript'
+    CHECK (process_type_new IN ('setupscript',
+                                'cleanupscript',   -- new value 🎉
+                                'codingagent',
+                                'devserver'));
+
+-- 2. Copy existing values across
+UPDATE execution_processes
+  SET process_type_new = process_type;
+
+-- 3. Drop any indexes that mention the old column
+DROP INDEX IF EXISTS idx_execution_processes_type;
+
+-- 4. Remove the old column (requires 3.35+)
+ALTER TABLE execution_processes DROP COLUMN process_type;
+
+-- 5. Rename the new column back to the canonical name
+ALTER TABLE execution_processes
+  RENAME COLUMN process_type_new TO process_type;
+
+-- 6. Re-create the index
+CREATE INDEX idx_execution_processes_type
+        ON execution_processes(process_type);

package/backend/migrations/20250723000000_add_wish_to_tasks.sql

@@ -0,0 +1,7 @@
+PRAGMA foreign_keys = ON;
+
+-- Add wish_id column to tasks table as required field
+ALTER TABLE tasks ADD COLUMN wish_id TEXT NOT NULL DEFAULT '';
+
+-- Create index for wish_id lookups
+CREATE INDEX idx_tasks_wish_id ON tasks(wish_id);

package/backend/migrations/20250724000000_remove_unique_wish_constraint.sql

@@ -0,0 +1,5 @@
+PRAGMA foreign_keys = ON;
+
+-- Remove the unique constraint index for wish_id that was incorrectly added
+-- wish_id is meant for grouping tasks, not uniqueness
+DROP INDEX IF EXISTS unique_wish_per_project;

package/backend/scripts/toast-notification.ps1

@@ -0,0 +1,23 @@
+param(
+    [Parameter(Mandatory=$true)]
+    [string]$Title,
+    
+    [Parameter(Mandatory=$true)]
+    [string]$Message,
+    
+    [Parameter(Mandatory=$false)]
+    [string]$AppName = "Automagik Forge"
+)
+
+[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+$Template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
+$RawXml = [xml] $Template.GetXml()
+($RawXml.toast.visual.binding.text|where {$_.id -eq "1"}).AppendChild($RawXml.CreateTextNode($Title)) | Out-Null
+($RawXml.toast.visual.binding.text|where {$_.id -eq "2"}).AppendChild($RawXml.CreateTextNode($Message)) | Out-Null
+$SerializedXml = New-Object Windows.Data.Xml.Dom.XmlDocument
+$SerializedXml.LoadXml($RawXml.OuterXml)
+$Toast = [Windows.UI.Notifications.ToastNotification]::new($SerializedXml)
+$Toast.Tag = $AppName
+$Toast.Group = $AppName
+$Notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier($AppName)
+$Notifier.Show($Toast)

package/backend/src/app_state.rs

@@ -0,0 +1,218 @@
+use std::{collections::HashMap, sync::Arc, time::Duration};
+
+#[cfg(unix)]
+use nix::{sys::signal::Signal, unistd::Pid};
+use tokio::sync::{Mutex, RwLock as TokioRwLock};
+use uuid::Uuid;
+
+use crate::services::{generate_user_id, AnalyticsConfig, AnalyticsService};
+
+#[derive(Debug)]
+pub enum ExecutionType {
+    SetupScript,
+    CleanupScript,
+    CodingAgent,
+    DevServer,
+}
+
+#[derive(Debug)]
+pub struct RunningExecution {
+    pub task_attempt_id: Uuid,
+    pub _execution_type: ExecutionType,
+    pub child: command_group::AsyncGroupChild,
+}
+
+#[derive(Debug, Clone)]
+pub struct AppState {
+    running_executions: Arc<Mutex<HashMap<Uuid, RunningExecution>>>,
+    pub db_pool: sqlx::SqlitePool,
+    config: Arc<tokio::sync::RwLock<crate::models::config::Config>>,
+    pub analytics: Arc<TokioRwLock<AnalyticsService>>,
+    user_id: String,
+}
+
+impl AppState {
+    pub async fn new(
+        db_pool: sqlx::SqlitePool,
+        config: Arc<tokio::sync::RwLock<crate::models::config::Config>>,
+    ) -> Self {
+        // Initialize analytics with user preferences
+        let user_enabled = {
+            let config_guard = config.read().await;
+            config_guard.analytics_enabled.unwrap_or(true)
+        };
+
+        let analytics_config = AnalyticsConfig::new(user_enabled);
+        let analytics = Arc::new(TokioRwLock::new(AnalyticsService::new(analytics_config)));
+
+        Self {
+            running_executions: Arc::new(Mutex::new(HashMap::new())),
+            db_pool,
+            config,
+            analytics,
+            user_id: generate_user_id(),
+        }
+    }
+
+    pub async fn update_analytics_config(&self, user_enabled: bool) {
+        // Check if analytics was disabled before this update
+        let was_analytics_disabled = {
+            let analytics = self.analytics.read().await;
+            !analytics.is_enabled()
+        };
+
+        let new_config = AnalyticsConfig::new(user_enabled);
+        let new_service = AnalyticsService::new(new_config);
+        let mut analytics = self.analytics.write().await;
+        *analytics = new_service;
+
+        // If analytics was disabled and is now enabled, fire a session_start event
+        if was_analytics_disabled && analytics.is_enabled() {
+            analytics.track_event(&self.user_id, "session_start", None);
+        }
+    }
+
+    // Running executions getters
+    pub async fn has_running_execution(&self, attempt_id: Uuid) -> bool {
+        let executions = self.running_executions.lock().await;
+        executions
+            .values()
+            .any(|exec| exec.task_attempt_id == attempt_id)
+    }
+
+    pub async fn get_running_executions_for_monitor(&self) -> Vec<(Uuid, Uuid, bool, Option<i64>)> {
+        let mut executions = self.running_executions.lock().await;
+        let mut completed_executions = Vec::new();
+
+        for (execution_id, running_exec) in executions.iter_mut() {
+            match running_exec.child.try_wait() {
+                Ok(Some(status)) => {
+                    let success = status.success();
+                    let exit_code = status.code().map(|c| c as i64);
+                    completed_executions.push((
+                        *execution_id,
+                        running_exec.task_attempt_id,
+                        success,
+                        exit_code,
+                    ));
+                }
+                Ok(None) => {
+                    // Still running
+                }
+                Err(e) => {
+                    tracing::error!("Error checking process status: {}", e);
+                    completed_executions.push((
+                        *execution_id,
+                        running_exec.task_attempt_id,
+                        false,
+                        None,
+                    ));
+                }
+            }
+        }
+
+        // Remove completed executions from the map
+        for (execution_id, _, _, _) in &completed_executions {
+            executions.remove(execution_id);
+        }
+
+        completed_executions
+    }
+
+    // Running executions setters
+    pub async fn add_running_execution(&self, execution_id: Uuid, execution: RunningExecution) {
+        let mut executions = self.running_executions.lock().await;
+        executions.insert(execution_id, execution);
+    }
+
+    pub async fn stop_running_execution_by_id(
+        &self,
+        execution_id: Uuid,
+    ) -> Result<bool, Box<dyn std::error::Error + Send + Sync>> {
+        let mut executions = self.running_executions.lock().await;
+        let Some(exec) = executions.get_mut(&execution_id) else {
+            return Ok(false);
+        };
+
+        // hit the whole process group, not just the leader
+        #[cfg(unix)]
+        {
+            use nix::{sys::signal::killpg, unistd::getpgid};
+
+            let pgid = getpgid(Some(Pid::from_raw(exec.child.id().unwrap() as i32)))?;
+            for sig in [Signal::SIGINT, Signal::SIGTERM, Signal::SIGKILL] {
+                killpg(pgid, sig)?;
+                tokio::time::sleep(Duration::from_secs(2)).await;
+                if exec.child.try_wait()?.is_some() {
+                    break; // gone!
+                }
+            }
+        }
+
+        // final fallback – command_group already targets the group
+        exec.child.kill().await.ok();
+        exec.child.wait().await.ok(); // reap
+
+        // only NOW remove it
+        executions.remove(&execution_id);
+        Ok(true)
+    }
+
+    // Config getters
+    pub async fn get_sound_alerts_enabled(&self) -> bool {
+        let config = self.config.read().await;
+        config.sound_alerts
+    }
+
+    pub async fn get_push_notifications_enabled(&self) -> bool {
+        let config = self.config.read().await;
+        config.push_notifications
+    }
+
+    pub async fn get_sound_file(&self) -> crate::models::config::SoundFile {
+        let config = self.config.read().await;
+        config.sound_file.clone()
+    }
+
+    pub fn get_config(&self) -> &Arc<tokio::sync::RwLock<crate::models::config::Config>> {
+        &self.config
+    }
+
+    pub async fn track_analytics_event(
+        &self,
+        event_name: &str,
+        properties: Option<serde_json::Value>,
+    ) {
+        let analytics = self.analytics.read().await;
+        if analytics.is_enabled() {
+            analytics.track_event(&self.user_id, event_name, properties);
+        } else {
+            tracing::debug!("Analytics disabled, skipping event: {}", event_name);
+        }
+    }
+
+    pub async fn update_sentry_scope(&self) {
+        let config = self.get_config().read().await;
+        let username = config.github.username.clone();
+        let email = config.github.primary_email.clone();
+        drop(config);
+
+        let sentry_user = if username.is_some() || email.is_some() {
+            sentry::User {
+                id: Some(self.user_id.clone()),
+                username,
+                email,
+                ..Default::default()
+            }
+        } else {
+            sentry::User {
+                id: Some(self.user_id.clone()),
+                ..Default::default()
+            }
+        };
+
+        sentry::configure_scope(|scope| {
+            scope.set_user(Some(sentry_user));
+        });
+    }
+}

package/backend/src/bin/generate_types.rs

@@ -0,0 +1,189 @@
+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/");
+    }
+}