Feature/mcb loc reduction

Cargo.toml

@@ -319,6 +319,9 @@ jsonpath-rust = "1.0.4"
 # Lazy static values
 once_cell = "1.19"
 
+# ORM
+sea-orm = { version = "1", features = ["sqlx-sqlite", "runtime-tokio-rustls"] }
+
 # ============================================
 # Build Profiles
 # ============================================

crates/mcb-application/src/use_cases/indexing_service.rs

@@ -26,13 +26,13 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Instant;
 
-use ignore::WalkBuilder;
 use mcb_domain::constants::{INDEXING_STATUS_COMPLETED, INDEXING_STATUS_STARTED};
 use mcb_domain::error::Result;
 use mcb_domain::events::DomainEvent;
 use mcb_domain::ports::{
-    ContextServiceInterface, EventBusProvider, FileHashRepository, IndexingOperationsInterface,
-    IndexingResult, IndexingServiceInterface, IndexingStatus, LanguageChunkingProvider,
+    ContextServiceInterface, EventBusProvider, FileHashRepository, FileSystemProvider,
+    IndexingOperationsInterface, IndexingResult, IndexingServiceInterface, IndexingStatus,
+    LanguageChunkingProvider, TaskRunnerProvider,
 };
 use mcb_domain::value_objects::{CollectionId, OperationId};
 use tracing::{error, info, warn};
@@ -102,11 +102,14 @@ pub struct IndexingServiceImpl {
     language_chunker: Arc<dyn LanguageChunkingProvider>,
     indexing_ops: Arc<dyn IndexingOperationsInterface>,
     event_bus: Arc<dyn EventBusProvider>,
+    file_system_provider: Arc<dyn FileSystemProvider>,
+    task_runner_provider: Arc<dyn TaskRunnerProvider>,
     file_hash_repository: Option<Arc<dyn FileHashRepository>>,
     supported_extensions: Vec<String>,
 }
 
 /// `IndexingServiceDeps` struct.
+#[allow(missing_docs)]
 pub struct IndexingServiceDeps {
     /// Service for Context operations
     pub context_service: Arc<dyn ContextServiceInterface>,
@@ -116,6 +119,8 @@ pub struct IndexingServiceDeps {
     pub indexing_ops: Arc<dyn IndexingOperationsInterface>,
     /// Event bus
     pub event_bus: Arc<dyn EventBusProvider>,
+    pub file_system_provider: Arc<dyn FileSystemProvider>,
+    pub task_runner_provider: Arc<dyn TaskRunnerProvider>,
     /// Supported file extensions
     pub supported_extensions: Vec<String>,
 }
@@ -139,13 +144,17 @@ impl IndexingServiceImpl {
         language_chunker: Arc<dyn LanguageChunkingProvider>,
         indexing_ops: Arc<dyn IndexingOperationsInterface>,
         event_bus: Arc<dyn EventBusProvider>,
+        file_system_provider: Arc<dyn FileSystemProvider>,
+        task_runner_provider: Arc<dyn TaskRunnerProvider>,
         supported_extensions: Vec<String>,
     ) -> Self {
         Self {
             context_service,
             language_chunker,
             indexing_ops,
             event_bus,
+            file_system_provider,
+            task_runner_provider,
             file_hash_repository: None,
             supported_extensions: Self::normalize_supported_extensions(supported_extensions),
         }
@@ -163,6 +172,8 @@ impl IndexingServiceImpl {
             language_chunker: service.language_chunker,
             indexing_ops: service.indexing_ops,
             event_bus: service.event_bus,
+            file_system_provider: service.file_system_provider,
+            task_runner_provider: service.task_runner_provider,
             file_hash_repository: Some(file_hash_repository),
             supported_extensions: Self::normalize_supported_extensions(
                 service.supported_extensions,
@@ -185,31 +196,32 @@ impl IndexingServiceImpl {
         progress: &mut IndexingProgress,
     ) -> Vec<std::path::PathBuf> {
         let mut files = Vec::new();
-        let walker = WalkBuilder::new(path)
-            .hidden(false)
-            .filter_entry(|entry| {
-                if !entry.file_type().is_some_and(|ft| ft.is_dir()) {
-                    return true;
-                }
-
-                entry
-                    .file_name()
-                    .to_str()
-                    .is_none_or(|name| !SKIP_DIRS.contains(&name))
-            })
-            .build();
-
-        for entry_result in walker {
-            match entry_result {
-                Ok(entry) => {
-                    if entry.file_type().is_some_and(|ft| ft.is_file())
-                        && self.is_supported_file(entry.path())
-                    {
-                        files.push(entry.path().to_path_buf());
+        let mut dirs = vec![path.to_path_buf()];
+
+        while let Some(dir) = dirs.pop() {
+            match self.file_system_provider.read_dir_entries(&dir).await {
+                Ok(entries) => {
+                    for entry in entries {
+                        if entry.is_dir {
+                            let should_skip = entry
+                                .path
+                                .file_name()
+                                .and_then(|n| n.to_str())
+                                .is_some_and(|name| SKIP_DIRS.contains(&name));
+
+                            if !should_skip {
+                                dirs.push(entry.path);
+                            }
+                            continue;
+                        }
+
+                        if entry.is_file && self.is_supported_file(&entry.path) {
+                            files.push(entry.path);
+                        }
                     }
                 }
                 Err(e) => {
-                    progress.record_error("Failed to read directory entry", path, e);
+                    progress.record_error("Failed to read directory entries", &dir, e);
                 }
             }
         }
@@ -286,10 +298,14 @@ impl IndexingServiceInterface for IndexingServiceImpl {
 
         // Fire-and-forget: caller gets operation_id immediately, polling for completion.
         // Sync execution path available via run_indexing_task() directly in tests.
-        let _handle = tokio::spawn(async move {
+        let task = Box::pin(async move {
             Self::run_indexing_task(service, files, workspace_root, collection_id, op_id).await;
         });
 
+        if let Err(e) = self.task_runner_provider.spawn(task) {
+            warn!("Failed to spawn indexing background task: {}", e);
+        }
+
         // Return immediately with operation_id
         Ok(IndexingResult {
             files_processed: 0,
@@ -424,19 +440,16 @@ impl IndexingServiceImpl {
             .update_progress(operation_id, Some(relative_path.clone()), index);
 
         // Read file content
-        let content = std::fs::read_to_string(file_path)
-            .map_err(|e| mcb_domain::error::Error::internal(format!("Failed to read file: {e}")))?;
+        let content = self.file_system_provider.read_to_string(file_path).await?;
 
         // Incremental check using file hashes
         let current_hash = mcb_domain::utils::compute_content_hash(&content);
-        #[allow(clippy::collapsible_if)]
-        if let Some(repo) = &self.file_hash_repository {
-            if !repo
+        if let Some(repo) = &self.file_hash_repository
+            && !repo
                 .has_changed(&collection.to_string(), &relative_path, &current_hash)
                 .await?
-            {
-                return Ok(ProcessResult::Skipped);
-            }
+        {
+            return Ok(ProcessResult::Skipped);
         }
 
         // Generate semantic chunks

crates/mcb-domain/Cargo.toml

@@ -62,8 +62,6 @@ futures = { workspace = true }
 # Plugin registration
 linkme = { workspace = true }
 
-# HTTP Client types for providers
-reqwest = { workspace = true }
 toml = { workspace = true, optional = true }
 
 [features]

crates/mcb-domain/src/entities/api_key.rs

@@ -26,3 +26,27 @@ crate::define_entity! {
         pub revoked_at: Option<i64>,
     }
 }
+
+crate::impl_table_schema!(ApiKey, "api_keys",
+    columns: [
+        ("id", Text, pk),
+        ("user_id", Text),
+        ("org_id", Text),
+        ("key_hash", Text),
+        ("name", Text),
+        ("scopes_json", Text),
+        ("expires_at", Integer, nullable),
+        ("created_at", Integer),
+        ("revoked_at", Integer, nullable),
+    ],
+    indexes: [
+        "idx_api_keys_user" => ["user_id"],
+        "idx_api_keys_org" => ["org_id"],
+        "idx_api_keys_key_hash" => ["key_hash"],
+    ],
+    foreign_keys: [
+        ("user_id", "users", "id"),
+        ("org_id", "organizations", "id"),
+    ],
+    unique_constraints: [],
+);

crates/mcb-domain/src/entities/organization.rs

@@ -44,3 +44,17 @@ pub enum OrgStatus {
 }
 
 crate::impl_as_str_from_as_ref!(OrgStatus);
+
+crate::impl_table_schema!(Organization, "organizations",
+    columns: [
+        ("id", Text, pk),
+        ("name", Text),
+        ("slug", Text, unique),
+        ("settings_json", Text),
+        ("created_at", Integer),
+        ("updated_at", Integer),
+    ],
+    indexes: [
+        "idx_organizations_name" => ["name"],
+    ],
+);

crates/mcb-domain/src/entities/team.rs

@@ -58,3 +58,41 @@ pub enum TeamMemberRole {
 }
 
 crate::impl_as_str_from_as_ref!(TeamMemberRole);
+
+crate::impl_table_schema!(Team, "teams",
+    columns: [
+        ("id", Text, pk),
+        ("org_id", Text),
+        ("name", Text),
+        ("created_at", Integer),
+    ],
+    indexes: [
+        "idx_teams_org" => ["org_id"],
+    ],
+    foreign_keys: [
+        ("org_id", "organizations", "id"),
+    ],
+    unique_constraints: [
+        ["org_id", "name"],
+    ],
+);
+
+crate::impl_table_schema!(TeamMember, "team_members",
+    columns: [
+        ("team_id", Text, pk),
+        ("user_id", Text, pk),
+        ("role", Text),
+        ("joined_at", Integer),
+    ],
+    indexes: [
+        "idx_team_members_team" => ["team_id"],
+        "idx_team_members_user" => ["user_id"],
+    ],
+    foreign_keys: [
+        ("team_id", "teams", "id"),
+        ("user_id", "users", "id"),
+    ],
+    unique_constraints: [
+        ["team_id", "user_id"],
+    ],
+);

crates/mcb-domain/src/entities/user.rs

@@ -50,3 +50,27 @@ pub enum UserRole {
 }
 
 crate::impl_as_str_from_as_ref!(UserRole);
+
+crate::impl_table_schema!(User, "users",
+    columns: [
+        ("id", Text, pk),
+        ("org_id", Text),
+        ("email", Text),
+        ("display_name", Text),
+        ("role", Text),
+        ("api_key_hash", Text, nullable),
+        ("created_at", Integer),
+        ("updated_at", Integer),
+    ],
+    indexes: [
+        "idx_users_org" => ["org_id"],
+        "idx_users_email" => ["email"],
+        "idx_users_api_key_hash" => ["api_key_hash"],
+    ],
+    foreign_keys: [
+        ("org_id", "organizations", "id"),
+    ],
+    unique_constraints: [
+        ["org_id", "email"],
+    ],
+);

crates/mcb-domain/src/macros/di.rs

@@ -0,0 +1,41 @@
+/// Generates `Arc`-cloning getter methods for DI container fields.
+#[macro_export]
+macro_rules! arc_getters {
+    () => {};
+
+    ($name:ident : $ty:ty => $field:ident $(= $impl:ty)? , $($rest:tt)*) => {
+        #[doc = concat!("Get `", stringify!($name), "`.")]
+        #[must_use]
+        pub fn $name(&self) -> std::sync::Arc<$ty> {
+            std::sync::Arc::clone(&self.$field)
+        }
+
+        $crate::arc_getters! { $($rest)* }
+    };
+
+    ($name:ident : $ty:ty => $field:ident $(= $impl:ty)? $(,)?) => {
+        #[doc = concat!("Get `", stringify!($name), "`.")]
+        #[must_use]
+        pub fn $name(&self) -> std::sync::Arc<$ty> {
+            std::sync::Arc::clone(&self.$field)
+        }
+    };
+
+    ($name:ident : $ty:ty $(= $impl:ty)? , $($rest:tt)*) => {
+        #[doc = concat!("Get `", stringify!($name), "`.")]
+        #[must_use]
+        pub fn $name(&self) -> std::sync::Arc<$ty> {
+            std::sync::Arc::clone(&self.$name)
+        }
+
+        $crate::arc_getters! { $($rest)* }
+    };
+
+    ($name:ident : $ty:ty $(= $impl:ty)? $(,)?) => {
+        #[doc = concat!("Get `", stringify!($name), "`.")]
+        #[must_use]
+        pub fn $name(&self) -> std::sync::Arc<$ty> {
+            std::sync::Arc::clone(&self.$name)
+        }
+    };
+}

crates/mcb-domain/src/macros/mod.rs

@@ -19,3 +19,5 @@ mod ports;
 mod schema;
 #[macro_use]
 mod registry;
+#[macro_use]
+mod di;