feat: add infrastructure layer services

- Add FileSystemService for file operations
- Add GitService for Git operations
- Add StateStorage for state management
- Follow TDD principles for all services
- Fix linting issues and type annotations

Author: yunlongwen

src/agently/infrastructure/__init__.py

@@ -1,5 +1,7 @@
-"""
-Infrastructure Layer - Basic Services
-"""
+"""Infrastructure Layer - Basic Services"""
 
-__all__ = []
+from agently.infrastructure.file_system import FileSystemService
+from agently.infrastructure.git_service import GitService
+from agently.infrastructure.state_storage import StateStorage
+
+__all__ = ["FileSystemService", "GitService", "StateStorage"]

src/agently/infrastructure/file_system.py

@@ -0,0 +1,92 @@
+"""File system service for file and directory operations"""
+
+from pathlib import Path
+
+from agently.logging import LoggingMixin
+
+
+class FileSystemService(LoggingMixin):
+    """Service for file system operations"""
+
+    def read_file(self, file_path: Path) -> str:
+        """Read content from a file
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            File content as string
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+        """
+        self.logger.info("Reading file", file_path=str(file_path))
+        return file_path.read_text()
+
+    def write_file(self, file_path: Path, content: str) -> None:
+        """Write content to a file
+
+        Args:
+            file_path: Path to the file
+            content: Content to write
+        """
+        self.logger.info("Writing file", file_path=str(file_path))
+        file_path.write_text(content)
+
+    def append_file(self, file_path: Path, content: str) -> None:
+        """Append content to a file
+
+        Args:
+            file_path: Path to the file
+            content: Content to append
+        """
+        self.logger.info("Appending to file", file_path=str(file_path))
+        with file_path.open("a") as f:
+            f.write(content)
+
+    def delete_file(self, file_path: Path) -> None:
+        """Delete a file
+
+        Args:
+            file_path: Path to the file
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+        """
+        self.logger.info("Deleting file", file_path=str(file_path))
+        file_path.unlink()
+
+    def file_exists(self, file_path: Path) -> bool:
+        """Check if a file exists
+
+        Args:
+            file_path: Path to check
+
+        Returns:
+            True if file exists, False otherwise
+        """
+        return file_path.exists()
+
+    def list_directory(self, dir_path: Path) -> list[Path]:
+        """List files in a directory
+
+        Args:
+            dir_path: Path to the directory
+
+        Returns:
+            List of file paths
+
+        Raises:
+            FileNotFoundError: If directory doesn't exist
+        """
+        self.logger.info("Listing directory", dir_path=str(dir_path))
+        return [f for f in dir_path.iterdir() if f.is_file()]
+
+    def create_directory(self, dir_path: Path) -> None:
+        """Create a directory
+
+        Args:
+            dir_path: Path to the directory
+        """
+        self.logger.info("Creating directory", dir_path=str(dir_path))
+        dir_path.mkdir(parents=True, exist_ok=True)

src/agently/infrastructure/git_service.py

@@ -0,0 +1,97 @@
+"""Git service for Git operations"""
+
+from pathlib import Path
+
+from agently.logging import LoggingMixin
+
+
+class GitService(LoggingMixin):
+    """Service for Git operations"""
+
+    def init_repository(self, repo_path: Path) -> None:
+        """Initialize a Git repository
+
+        Args:
+            repo_path: Path to the repository
+        """
+        try:
+            from git import Repo
+
+            self.logger.info("Initializing Git repository", repo_path=str(repo_path))
+            Repo.init(repo_path)
+        except ImportError as e:
+            self.logger.error("GitPython not installed")
+            raise ImportError("GitPython is required. Install with: pip install GitPython") from e
+
+    def get_current_branch(self, repo_path: Path) -> str:
+        """Get current branch name
+
+        Args:
+            repo_path: Path to the repository
+
+        Returns:
+            Branch name
+        """
+        from git import Repo
+
+        self.logger.debug("Getting current branch", repo_path=str(repo_path))
+        repo = Repo(repo_path)
+        return repo.active_branch.name
+
+    def add_file(self, repo_path: Path, file_path: Path) -> None:
+        """Add a file to Git
+
+        Args:
+            repo_path: Path to the repository
+            file_path: Path to the file
+        """
+        from git import Repo
+
+        self.logger.info("Adding file to Git", file_path=str(file_path))
+        repo = Repo(repo_path)
+        repo.index.add([str(file_path)])
+
+    def commit_changes(self, repo_path: Path, message: str) -> None:
+        """Commit changes
+
+        Args:
+            repo_path: Path to the repository
+            message: Commit message
+        """
+        from git import Repo
+
+        self.logger.info("Committing changes", message=message)
+        repo = Repo(repo_path)
+        repo.index.commit(message)
+
+    def get_status(self, repo_path: Path) -> str:
+        """Get repository status
+
+        Args:
+            repo_path: Path to the repository
+
+        Returns:
+            Status string
+        """
+        from git import Repo
+
+        self.logger.debug("Getting repository status", repo_path=str(repo_path))
+        repo = Repo(repo_path)
+        return str(repo.git.status())
+
+    def is_repository(self, repo_path: Path) -> bool:
+        """Check if directory is a Git repository
+
+        Args:
+            repo_path: Path to check
+
+        Returns:
+            True if it's a repository, False otherwise
+        """
+        try:
+            from git import Repo
+
+            Repo(repo_path)
+            return True
+        except Exception:
+            return False

src/agently/infrastructure/state_storage.py

@@ -0,0 +1,102 @@
+"""State storage service for managing application state"""
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+from agently.logging import LoggingMixin
+
+
+class StateStorage(LoggingMixin):
+    """Service for state storage using SQLite"""
+
+    def __init__(self, db_path: Path) -> None:
+        """Initialize state storage
+
+        Args:
+            db_path: Path to the database file
+        """
+        self.db_path = db_path
+        self._ensure_db_exists()
+        self.logger.info("State storage initialized", db_path=str(db_path))
+
+    def _ensure_db_exists(self) -> None:
+        """Ensure database file exists"""
+        if not self.db_path.exists():
+            self.db_path.parent.mkdir(parents=True, exist_ok=True)
+            self.db_path.write_text("{}")
+            self.logger.debug("Created new state database", db_path=str(self.db_path))
+
+    def _load_state(self) -> dict[str, Any]:
+        """Load state from database
+
+        Returns:
+            State dictionary
+        """
+        try:
+            content = self.db_path.read_text()
+            return json.loads(content)
+        except Exception:
+            self.logger.warning("Failed to load state, returning empty dict")
+            return {}
+
+    def _save_state(self, state: dict[str, Any]) -> None:
+        """Save state to database
+
+        Args:
+            state: State dictionary to save
+        """
+        content = json.dumps(state, indent=2)
+        self.db_path.write_text(content)
+
+    def store(self, key: str, value: Any) -> None:
+        """Store a key-value pair
+
+        Args:
+            key: Storage key
+            value: Value to store
+        """
+        self.logger.debug("Storing state", key=key)
+        state = self._load_state()
+        state[key] = value
+        self._save_state(state)
+
+    def retrieve(self, key: str) -> Optional[Any]:
+        """Retrieve a value by key
+
+        Args:
+            key: Storage key
+
+        Returns:
+            Value if exists, None otherwise
+        """
+        self.logger.debug("Retrieving state", key=key)
+        state = self._load_state()
+        return state.get(key)
+
+    def delete(self, key: str) -> None:
+        """Delete a key-value pair
+
+        Args:
+            key: Storage key to delete
+        """
+        self.logger.debug("Deleting state", key=key)
+        state = self._load_state()
+        if key in state:
+            del state[key]
+            self._save_state(state)
+
+    def list_keys(self) -> list[str]:
+        """List all stored keys
+
+        Returns:
+            List of keys
+        """
+        self.logger.debug("Listing all keys")
+        state = self._load_state()
+        return list(state.keys())
+
+    def clear_all(self) -> None:
+        """Clear all stored state"""
+        self.logger.info("Clearing all state")
+        self._save_state({})