Refactor to clean architecture with layered separation of concerns

Implement comprehensive architectural restructuring for better testability and maintainability:

**Domain Layer** ():
- Models: Document, OutlineItem with rich domain methods
- Parsing: MarkdownParser trait with PulldownMarkdownParser implementation
- Services: FileService trait defining data access contracts

**Infrastructure Layer** ():
- RealFileService: Actual filesystem operations
- MockFileService: Test doubles for unit testing

**Application Layer** ():
- DocumentService: Coordinates domain and infrastructure
- ApplicationServices: Main service composition and dependency injection

**Presentation Layer** ():
- App: Main UI component using services via context
- Components: FileItem, MainPanel, OutlineItemComponent
- Styles: Extracted Solarized theme CSS

**Benefits**:
- TDD-friendly: Business logic testable without GUI dependencies
- Outside-in testing: Complete workflows testable with mocks
- Dependency injection: Services use trait abstractions for easy testing
- Scalability: Clear places for new features, plugin architecture ready
- Maintainability: Proper separation of concerns across layers

**Backwards Compatibility**: Legacy API maintained through lib.rs re-exports
**Test Coverage**: 13 comprehensive tests across all architectural layers

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: timabell

Cargo.lock

@@ -11,6 +11,7 @@ repository = "https://github.com/timabell/markdown-neuraxis"
 pulldown-cmark = "0.11"
 serde = { version = "1.0", features = ["derive"] }
 dioxus = { version = "0.6", features = ["desktop"] }
+thiserror = "1.0"
 
 [dev-dependencies]
 rstest = "0.23"

Cargo.toml

@@ -0,0 +1,3 @@
+pub mod services;
+
+pub use services::*;

src/app/mod.rs

@@ -0,0 +1,123 @@
+use crate::domain::models::{Document, FileEntry, NotesStructure};
+use crate::domain::parsing::MarkdownParser;
+use crate::domain::services::{FileService, FileServiceError};
+use crate::infrastructure::RealFileService;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+#[derive(Debug, thiserror::Error)]
+pub enum DocumentServiceError {
+    #[error("File service error: {0}")]
+    FileService(#[from] FileServiceError),
+    #[error("Parse error: {0}")]
+    Parse(String),
+}
+
+#[derive(Clone)]
+pub struct DocumentService {
+    file_service: Arc<dyn FileService>,
+    parser: Arc<dyn MarkdownParser>,
+}
+
+impl PartialEq for DocumentService {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.file_service, &other.file_service)
+            && Arc::ptr_eq(&self.parser, &other.parser)
+    }
+}
+
+impl DocumentService {
+    pub fn new(file_service: Arc<dyn FileService>, parser: Arc<dyn MarkdownParser>) -> Self {
+        Self {
+            file_service,
+            parser,
+        }
+    }
+
+    pub fn load_document(&self, path: &Path) -> Result<Document, DocumentServiceError> {
+        let content = self.file_service.read_file(path)?;
+        let document = self.parser.parse(&content, path.to_path_buf());
+        Ok(document)
+    }
+
+    pub fn scan_markdown_files(&self, root: &Path) -> Result<Vec<FileEntry>, DocumentServiceError> {
+        self.file_service
+            .scan_markdown_files(root)
+            .map_err(DocumentServiceError::FileService)
+    }
+
+    pub fn validate_notes_structure(
+        &self,
+        root: &Path,
+    ) -> Result<NotesStructure, DocumentServiceError> {
+        self.file_service
+            .validate_notes_structure(root)
+            .map_err(DocumentServiceError::FileService)
+    }
+}
+
+#[derive(Clone, PartialEq)]
+pub struct ApplicationServices {
+    pub document_service: DocumentService,
+}
+
+impl ApplicationServices {
+    pub fn new() -> Self {
+        let file_service = Arc::new(RealFileService::new());
+        let parser = Arc::new(crate::domain::parsing::PulldownMarkdownParser::new());
+        let document_service = DocumentService::new(file_service, parser);
+
+        Self { document_service }
+    }
+
+    #[cfg(test)]
+    pub fn with_mock_file_service(file_service: Arc<dyn FileService>) -> Self {
+        let parser = Arc::new(crate::domain::parsing::PulldownMarkdownParser::new());
+        let document_service = DocumentService::new(file_service, parser);
+
+        Self { document_service }
+    }
+}
+
+impl Default for ApplicationServices {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::infrastructure::MockFileService;
+
+    #[test]
+    fn test_document_service_with_mock() {
+        let mut mock_fs = MockFileService::new();
+        mock_fs.add_file("/test.md", "- Item 1\n- Item 2");
+
+        let services = ApplicationServices::with_mock_file_service(Arc::new(mock_fs));
+        let doc = services
+            .document_service
+            .load_document(Path::new("/test.md"))
+            .unwrap();
+
+        assert_eq!(doc.outline.len(), 2);
+        assert_eq!(doc.outline[0].content, "Item 1");
+        assert_eq!(doc.outline[1].content, "Item 2");
+    }
+
+    #[test]
+    fn test_scan_files_with_mock() {
+        let mut mock_fs = MockFileService::new();
+        mock_fs.add_file("/notes/test1.md", "# Test 1");
+        mock_fs.add_file("/notes/test2.md", "# Test 2");
+
+        let services = ApplicationServices::with_mock_file_service(Arc::new(mock_fs));
+        let files = services
+            .document_service
+            .scan_markdown_files(Path::new("/notes"))
+            .unwrap();
+
+        assert_eq!(files.len(), 2);
+    }
+}

src/app/services.rs

@@ -0,0 +1,7 @@
+pub mod models;
+pub mod parsing;
+pub mod services;
+
+pub use models::*;
+pub use parsing::*;
+pub use services::*;

src/domain/mod.rs

@@ -0,0 +1,68 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct OutlineItem {
+    pub content: String,
+    pub level: usize,
+    pub children: Vec<OutlineItem>,
+    pub metadata: HashMap<String, String>,
+}
+
+impl OutlineItem {
+    pub fn new(content: String, level: usize) -> Self {
+        Self {
+            content,
+            level,
+            children: Vec::new(),
+            metadata: HashMap::new(),
+        }
+    }
+
+    pub fn with_children(content: String, level: usize, children: Vec<OutlineItem>) -> Self {
+        Self {
+            content,
+            level,
+            children,
+            metadata: HashMap::new(),
+        }
+    }
+
+    pub fn add_child(&mut self, child: OutlineItem) {
+        self.children.push(child);
+    }
+
+    pub fn set_metadata(&mut self, key: String, value: String) {
+        self.metadata.insert(key, value);
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Document {
+    pub path: PathBuf,
+    pub outline: Vec<OutlineItem>,
+    pub frontmatter: HashMap<String, String>,
+}
+
+impl Document {
+    pub fn new(path: PathBuf) -> Self {
+        Self {
+            path,
+            outline: Vec::new(),
+            frontmatter: HashMap::new(),
+        }
+    }
+
+    pub fn with_outline(path: PathBuf, outline: Vec<OutlineItem>) -> Self {
+        Self {
+            path,
+            outline,
+            frontmatter: HashMap::new(),
+        }
+    }
+
+    pub fn add_outline_item(&mut self, item: OutlineItem) {
+        self.outline.push(item);
+    }
+}

src/domain/models/document.rs

@@ -0,0 +1,56 @@
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct FileEntry {
+    pub path: PathBuf,
+    pub is_directory: bool,
+    pub name: String,
+}
+
+impl FileEntry {
+    pub fn new(path: PathBuf, is_directory: bool) -> Self {
+        let name = path
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("Unknown")
+            .to_string();
+
+        Self {
+            path,
+            is_directory,
+            name,
+        }
+    }
+
+    pub fn is_markdown(&self) -> bool {
+        !self.is_directory
+            && self
+                .path
+                .extension()
+                .and_then(|ext| ext.to_str())
+                .map_or(false, |ext| ext == "md")
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct NotesStructure {
+    pub root: PathBuf,
+    pub pages_dir: PathBuf,
+    pub journal_dir: PathBuf,
+    pub assets_dir: PathBuf,
+}
+
+impl NotesStructure {
+    pub fn new(root: PathBuf) -> Self {
+        Self {
+            pages_dir: root.join("pages"),
+            journal_dir: root.join("journal"),
+            assets_dir: root.join("assets"),
+            root,
+        }
+    }
+
+    pub fn is_valid(&self) -> bool {
+        self.pages_dir.exists()
+    }
+}

src/domain/models/file_system.rs

@@ -0,0 +1,5 @@
+pub mod document;
+pub mod file_system;
+
+pub use document::*;
+pub use file_system::*;

src/domain/models/mod.rs

@@ -0,0 +1,89 @@
+use crate::domain::models::{Document, OutlineItem};
+use pulldown_cmark::{Event, Parser, Tag, TagEnd};
+use std::path::PathBuf;
+
+pub trait MarkdownParser: Send + Sync {
+    fn parse(&self, content: &str, path: PathBuf) -> Document;
+}
+
+#[derive(Debug, Default)]
+pub struct PulldownMarkdownParser;
+
+impl PulldownMarkdownParser {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+impl MarkdownParser for PulldownMarkdownParser {
+    fn parse(&self, content: &str, path: PathBuf) -> Document {
+        let parser = Parser::new(content);
+        let mut items: Vec<OutlineItem> = Vec::new();
+        let mut text_stack: Vec<String> = Vec::new();
+        let mut list_stack: Vec<usize> = Vec::new();
+        let mut in_item = false;
+
+        for event in parser {
+            match event {
+                Event::Start(Tag::List(_)) => {
+                    list_stack.push(0);
+                }
+                Event::End(TagEnd::List(_)) => {
+                    list_stack.pop();
+                }
+                Event::Start(Tag::Item) => {
+                    text_stack.push(String::new());
+                    in_item = true;
+                }
+                Event::Text(text) if in_item => {
+                    if let Some(current_text) = text_stack.last_mut() {
+                        current_text.push_str(&text);
+                    }
+                }
+                Event::End(TagEnd::Item) => {
+                    in_item = false;
+                    if let Some(text) = text_stack.pop() {
+                        if !text.trim().is_empty() {
+                            let level = list_stack.len().saturating_sub(1);
+                            let item = OutlineItem::new(text.trim().to_string(), level);
+                            items.push(item);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        let outline = super::outline::build_hierarchy(items);
+        Document::with_outline(path, outline)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::Path;
+
+    #[test]
+    fn test_parse_simple_markdown() {
+        let parser = PulldownMarkdownParser::new();
+        let content = "- First item\n- Second item";
+        let doc = parser.parse(content, PathBuf::from("/test.md"));
+
+        assert_eq!(doc.outline.len(), 2);
+        assert_eq!(doc.outline[0].content, "First item");
+        assert_eq!(doc.outline[1].content, "Second item");
+    }
+
+    #[test]
+    fn test_parse_nested_markdown() {
+        let parser = PulldownMarkdownParser::new();
+        let content = "- Parent\n  - Child";
+        let doc = parser.parse(content, PathBuf::from("/test.md"));
+
+        assert_eq!(doc.outline.len(), 1);
+        assert_eq!(doc.outline[0].content, "Parent");
+        assert_eq!(doc.outline[0].children.len(), 1);
+        assert_eq!(doc.outline[0].children[0].content, "Child");
+    }
+}

src/domain/parsing/markdown.rs

@@ -0,0 +1,5 @@
+pub mod markdown;
+pub mod outline;
+
+pub use markdown::*;
+pub use outline::*;