cli: Migrate integration config persistence to hexagonal slice

Extract repository-scoped integration configuration persistence from
services::setup into a narrow IntegrationConfigRepository port, three
application use cases (EnsureRepoConfig, LoadPersistedOptionalWorkflows,
RecordIntegrationInstallation), and a filesystem outbound adapter
owning .sce/config.json lifecycle, JSON merge, and serialization.
IntegrationTarget gains config_id() for canonical target identifiers.
Public setup functions remain compatibility facades preserving existing
error context, ordering, and best-effort behavior.

Co-authored-by: SCE <sce@crocoder.dev>

Author: davidabram

cli/src/adapters/outbound/filesystem/integration_config_repository.rs

@@ -1,4 +1,5 @@
 //! Filesystem-backed outbound adapters.
 
 pub(crate) mod context_store;
+pub(crate) mod integration_config_repository;
 pub(crate) mod integration_installer;

cli/src/adapters/outbound/filesystem/mod.rs

@@ -0,0 +1,30 @@
+//! `IntegrationConfigRepository` port: owns repo-local `.sce/config.json`
+//! lifecycle for integration configuration, owned by an outbound adapter and
+//! consumed by the repository-config use cases.
+
+use std::path::Path;
+
+use crate::domain::integration::IntegrationTarget;
+
+/// Owns repo-local integration configuration persistence: bootstrap,
+/// optional-workflow reads, and recording concrete installed targets.
+pub(crate) trait IntegrationConfigRepository {
+    type Error;
+
+    /// Creates the repo-local config file with the canonical bootstrap
+    /// payload if it does not already exist; leaves an existing file
+    /// untouched.
+    fn ensure_exists(&self, repository_root: &Path) -> Result<(), Self::Error>;
+
+    /// The optional workflows currently recorded in the repo-local config.
+    fn load_optional_workflows(&self, repository_root: &Path) -> Result<Vec<String>, Self::Error>;
+
+    /// Records the given concrete targets as installed and replaces the
+    /// recorded optional-workflow selection.
+    fn record_installation(
+        &self,
+        repository_root: &Path,
+        targets: &[IntegrationTarget],
+        optional_workflows: &[String],
+    ) -> Result<(), Self::Error>;
+}

cli/src/application/ports/integration_config_repository.rs

@@ -2,4 +2,5 @@
 
 pub(crate) mod context_store;
 pub(crate) mod integration_asset_catalog;
+pub(crate) mod integration_config_repository;
 pub(crate) mod integration_installer;

cli/src/application/ports/mod.rs

@@ -0,0 +1,106 @@
+//! `EnsureRepoConfig` use case: ensures the repo-local integration
+//! configuration file exists, delegating persistence to an injected
+//! `IntegrationConfigRepository`.
+
+use std::path::PathBuf;
+
+use crate::application::ports::integration_config_repository::IntegrationConfigRepository;
+
+/// The repository root to ensure repo-local integration configuration
+/// against.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct EnsureRepoConfigRequest {
+    pub(crate) repository_root: PathBuf,
+}
+
+/// Ensures the repo-local integration configuration file exists, via an
+/// injected `IntegrationConfigRepository`.
+pub(crate) struct EnsureRepoConfig<R: IntegrationConfigRepository> {
+    repository: R,
+}
+
+impl<R: IntegrationConfigRepository> EnsureRepoConfig<R> {
+    pub(crate) fn new(repository: R) -> Self {
+        Self { repository }
+    }
+
+    pub(crate) fn execute(&self, request: &EnsureRepoConfigRequest) -> Result<(), R::Error> {
+        self.repository.ensure_exists(&request.repository_root)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::cell::RefCell;
+    use std::path::Path;
+
+    use crate::domain::integration::IntegrationTarget;
+
+    #[derive(Default)]
+    struct FakeRepository {
+        ensure_exists_calls: RefCell<Vec<PathBuf>>,
+        ensure_exists_error: Option<&'static str>,
+    }
+
+    impl IntegrationConfigRepository for FakeRepository {
+        type Error = &'static str;
+
+        fn ensure_exists(&self, repository_root: &Path) -> Result<(), Self::Error> {
+            self.ensure_exists_calls
+                .borrow_mut()
+                .push(repository_root.to_path_buf());
+
+            self.ensure_exists_error.map_or(Ok(()), Err)
+        }
+
+        fn load_optional_workflows(
+            &self,
+            _repository_root: &Path,
+        ) -> Result<Vec<String>, Self::Error> {
+            unreachable!("not exercised by EnsureRepoConfig")
+        }
+
+        fn record_installation(
+            &self,
+            _repository_root: &Path,
+            _targets: &[IntegrationTarget],
+            _optional_workflows: &[String],
+        ) -> Result<(), Self::Error> {
+            unreachable!("not exercised by EnsureRepoConfig")
+        }
+    }
+
+    #[test]
+    fn execute_delegates_to_ensure_exists_with_the_resolved_root() {
+        let repository = FakeRepository::default();
+        let use_case = EnsureRepoConfig::new(repository);
+        let repository_root = PathBuf::from("/repo");
+
+        use_case
+            .execute(&EnsureRepoConfigRequest {
+                repository_root: repository_root.clone(),
+            })
+            .unwrap();
+
+        assert_eq!(
+            use_case.repository.ensure_exists_calls.borrow().as_slice(),
+            [repository_root]
+        );
+    }
+
+    #[test]
+    fn execute_propagates_repository_errors() {
+        let repository = FakeRepository {
+            ensure_exists_calls: RefCell::new(Vec::new()),
+            ensure_exists_error: Some("ensure_exists failed"),
+        };
+        let use_case = EnsureRepoConfig::new(repository);
+
+        let result = use_case.execute(&EnsureRepoConfigRequest {
+            repository_root: PathBuf::from("/repo"),
+        });
+
+        assert_eq!(result, Err("ensure_exists failed"));
+    }
+}

cli/src/application/use_cases/ensure_repo_config.rs

@@ -0,0 +1,116 @@
+//! `LoadPersistedOptionalWorkflows` use case: reads the optional workflows
+//! currently recorded in repo-local integration configuration, delegating to
+//! an injected `IntegrationConfigRepository`.
+
+use std::path::PathBuf;
+
+use crate::application::ports::integration_config_repository::IntegrationConfigRepository;
+
+/// The repository root to load persisted optional workflows from.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct LoadPersistedOptionalWorkflowsRequest {
+    pub(crate) repository_root: PathBuf,
+}
+
+/// Reads the optional workflows currently recorded in repo-local integration
+/// configuration, via an injected `IntegrationConfigRepository`.
+pub(crate) struct LoadPersistedOptionalWorkflows<R: IntegrationConfigRepository> {
+    repository: R,
+}
+
+impl<R: IntegrationConfigRepository> LoadPersistedOptionalWorkflows<R> {
+    pub(crate) fn new(repository: R) -> Self {
+        Self { repository }
+    }
+
+    pub(crate) fn execute(
+        &self,
+        request: &LoadPersistedOptionalWorkflowsRequest,
+    ) -> Result<Vec<String>, R::Error> {
+        self.repository
+            .load_optional_workflows(&request.repository_root)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::cell::RefCell;
+    use std::path::Path;
+
+    use crate::domain::integration::IntegrationTarget;
+
+    struct FakeRepository {
+        load_optional_workflows_calls: RefCell<Vec<PathBuf>>,
+        load_optional_workflows_result: Result<Vec<String>, &'static str>,
+    }
+
+    impl IntegrationConfigRepository for FakeRepository {
+        type Error = &'static str;
+
+        fn ensure_exists(&self, _repository_root: &Path) -> Result<(), Self::Error> {
+            unreachable!("not exercised by LoadPersistedOptionalWorkflows")
+        }
+
+        fn load_optional_workflows(
+            &self,
+            repository_root: &Path,
+        ) -> Result<Vec<String>, Self::Error> {
+            self.load_optional_workflows_calls
+                .borrow_mut()
+                .push(repository_root.to_path_buf());
+
+            self.load_optional_workflows_result.clone()
+        }
+
+        fn record_installation(
+            &self,
+            _repository_root: &Path,
+            _targets: &[IntegrationTarget],
+            _optional_workflows: &[String],
+        ) -> Result<(), Self::Error> {
+            unreachable!("not exercised by LoadPersistedOptionalWorkflows")
+        }
+    }
+
+    #[test]
+    fn execute_returns_the_repositorys_workflows_unchanged() {
+        let repository = FakeRepository {
+            load_optional_workflows_calls: RefCell::new(Vec::new()),
+            load_optional_workflows_result: Ok(vec!["research".to_string(), "docs".to_string()]),
+        };
+        let use_case = LoadPersistedOptionalWorkflows::new(repository);
+        let repository_root = PathBuf::from("/repo");
+
+        let workflows = use_case
+            .execute(&LoadPersistedOptionalWorkflowsRequest {
+                repository_root: repository_root.clone(),
+            })
+            .unwrap();
+
+        assert_eq!(workflows, vec!["research".to_string(), "docs".to_string()]);
+        assert_eq!(
+            use_case
+                .repository
+                .load_optional_workflows_calls
+                .borrow()
+                .as_slice(),
+            [repository_root]
+        );
+    }
+
+    #[test]
+    fn execute_propagates_repository_errors_unchanged() {
+        let repository = FakeRepository {
+            load_optional_workflows_calls: RefCell::new(Vec::new()),
+            load_optional_workflows_result: Err("load failed"),
+        };
+        let use_case = LoadPersistedOptionalWorkflows::new(repository);
+
+        let result = use_case.execute(&LoadPersistedOptionalWorkflowsRequest {
+            repository_root: PathBuf::from("/repo"),
+        });
+
+        assert_eq!(result, Err("load failed"));
+    }
+}

cli/src/application/use_cases/load_persisted_optional_workflows.rs

@@ -1,4 +1,7 @@
 //! Use cases: application-specific orchestration of domain and ports.
 
 pub(crate) mod ensure_context_baseline;
+pub(crate) mod ensure_repo_config;
 pub(crate) mod install_integration_assets;
+pub(crate) mod load_persisted_optional_workflows;
+pub(crate) mod record_integration_installation;