feat: add main features

Agents for developpement added + frontend add + backend added. Git viewer created + agent and template creator + layout and project creator

crates/application/src/project/close.rs

@@ -0,0 +1,97 @@
+//! [`CloseProject`] / [`CloseTab`] (ARCHITECTURE §6).
+//!
+//! In L2 there are no PTYs to release yet, so closing is essentially *persisting
+//! the current state*. The use case takes the workspace image to persist (the
+//! UI owns the windows/tabs arrangement) and saves it through the
+//! [`ProjectStore`]. It is written so the L3 "release PTYs" step slots in here
+//! without changing the call sites.
+
+use std::sync::Arc;
+
+use domain::ports::ProjectStore;
+use domain::{ProjectId, Workspace};
+
+use crate::error::AppError;
+
+/// Input for [`CloseProject::execute`].
+#[derive(Debug, Clone, PartialEq)]
+pub struct CloseProjectInput {
+    /// The project being closed.
+    pub project_id: ProjectId,
+    /// The workspace state to persist (windows/tabs/layouts). `None` skips
+    /// persistence (e.g. the UI has nothing to save).
+    pub workspace: Option<Workspace>,
+}
+
+/// Output of [`CloseProject::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CloseProjectOutput {
+    /// The project that was closed.
+    pub project_id: ProjectId,
+}
+
+/// Closes a project: persists the workspace state and releases resources.
+pub struct CloseProject {
+    store: Arc<dyn ProjectStore>,
+}
+
+impl CloseProject {
+    /// Builds the use case from its injected port.
+    #[must_use]
+    pub fn new(store: Arc<dyn ProjectStore>) -> Self {
+        Self { store }
+    }
+
+    /// Executes the close.
+    ///
+    /// # Errors
+    /// [`AppError::Store`] if persisting the workspace fails.
+    pub async fn execute(&self, input: CloseProjectInput) -> Result<CloseProjectOutput, AppError> {
+        if let Some(workspace) = &input.workspace {
+            self.store.save_workspace(workspace).await?;
+        }
+        // L3 will release the project's PTYs here.
+        Ok(CloseProjectOutput {
+            project_id: input.project_id,
+        })
+    }
+}
+
+/// Input for [`CloseTab::execute`] — closing one tab (a single open project).
+#[derive(Debug, Clone, PartialEq)]
+pub struct CloseTabInput {
+    /// The project shown in the tab being closed.
+    pub project_id: ProjectId,
+    /// The workspace state to persist after the tab is removed.
+    pub workspace: Option<Workspace>,
+}
+
+/// Closes a single tab. In L2 this delegates to the same persistence path as
+/// [`CloseProject`]; it exists as a distinct intention so the multi-window lot
+/// (L10) can give it tab-specific behaviour without touching callers.
+pub struct CloseTab {
+    inner: CloseProject,
+}
+
+impl CloseTab {
+    /// Builds the use case from its injected port.
+    #[must_use]
+    pub fn new(store: Arc<dyn ProjectStore>) -> Self {
+        Self {
+            inner: CloseProject::new(store),
+        }
+    }
+
+    /// Executes the tab close.
+    ///
+    /// # Errors
+    /// [`AppError::Store`] if persisting the workspace fails.
+    pub async fn execute(&self, input: CloseTabInput) -> Result<CloseProjectOutput, AppError> {
+        self.inner
+            .execute(CloseProjectInput {
+                project_id: input.project_id,
+                workspace: input.workspace,
+            })
+            .await
+    }
+}