tempit-manager 0.1.0__tar.gz

tempit_manager-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 idirxv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tempit_manager-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.3
+Name: tempit-manager
+Version: 0.1.0
+Summary: Manage and jump into temporary working directories
+Author: Idir Oura
+Author-email: idir.oura@protonmail.com
+Requires-Python: >=3.10,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: flake8 (>=7.3.0,<8.0.0)
+Requires-Dist: humanize
+Requires-Dist: mypy (>=1.18.1,<2.0.0)
+Requires-Dist: pylint (>=3.3.8,<4.0.0)
+Requires-Dist: pytest (>=8.4.2,<9.0.0)
+Requires-Dist: ruff (>=0.13.0,<0.14.0)
+Requires-Dist: tabulate
+Requires-Dist: termcolor
+Description-Content-Type: text/markdown
+
+# Tempit - Temporary Directory Manager
+
+Tempit is a command-line utility and shell helper that lets you create, track, and jump to temporary directories without losing them.
+## Features
+
+- Create temporary directories with optional prefixes.
+- List tracked directories with size, creation time, age, and file counts.
+- Jump to a directory by its number.
+- Remove individual directories or clean them all.
+- Works via shell integration.
+
+## Installation
+
+### Using pip
+
+```bash
+pip install tempit
+```
+
+### Shell integration
+
+Add the following line to your shell startup file (`~/.bashrc` or `~/.zshrc`):
+
+```bash
+# Bash
+eval "$(tempit --init bash)"
+
+# Zsh
+eval "$(tempit --init zsh)"
+```
+
+## Usage
+
+### CLI commands
+
+```bash
+tempit --create [prefix]
+tempit --list
+tempit --remove <number>
+tempit --clean-all
+```
+
+### Aliases (after shell init)
+
+| Alias | Description |
+|-------|-------------|
+| `tempc [prefix]` | Create a new temporary directory and cd into it |
+| `tempg <number>` | Change into the directory by its number |
+| `templ` | List tracked temporary directories |
+
+## License
+
+[MIT](LICENSE)
+

tempit_manager-0.1.0/README.md

@@ -0,0 +1,53 @@
+# Tempit - Temporary Directory Manager
+
+Tempit is a command-line utility and shell helper that lets you create, track, and jump to temporary directories without losing them.
+## Features
+
+- Create temporary directories with optional prefixes.
+- List tracked directories with size, creation time, age, and file counts.
+- Jump to a directory by its number.
+- Remove individual directories or clean them all.
+- Works via shell integration.
+
+## Installation
+
+### Using pip
+
+```bash
+pip install tempit
+```
+
+### Shell integration
+
+Add the following line to your shell startup file (`~/.bashrc` or `~/.zshrc`):
+
+```bash
+# Bash
+eval "$(tempit --init bash)"
+
+# Zsh
+eval "$(tempit --init zsh)"
+```
+
+## Usage
+
+### CLI commands
+
+```bash
+tempit --create [prefix]
+tempit --list
+tempit --remove <number>
+tempit --clean-all
+```
+
+### Aliases (after shell init)
+
+| Alias | Description |
+|-------|-------------|
+| `tempc [prefix]` | Create a new temporary directory and cd into it |
+| `tempg <number>` | Change into the directory by its number |
+| `templ` | List tracked temporary directories |
+
+## License
+
+[MIT](LICENSE)

tempit_manager-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["poetry-core>=2.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[project]
+name = "tempit-manager"
+version = "0.1.0"
+description = "Manage and jump into temporary working directories"
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+authors = [{ name = "Idir Oura", email = "idir.oura@protonmail.com" }]
+dependencies = [
+    "humanize",
+    "tabulate",
+    "termcolor",
+    "pytest (>=8.4.2,<9.0.0)",
+    "flake8 (>=7.3.0,<8.0.0)",
+    "ruff (>=0.13.0,<0.14.0)",
+    "mypy (>=1.18.1,<2.0.0)",
+    "pylint (>=3.3.8,<4.0.0)"
+]
+
+[project.scripts]
+tempit = "tempit.cli:main"
+
+[tool.poetry]
+packages = [{ include = "tempit" }]
+include = [
+  { path = "tempit/shell/init.sh" }
+]

tempit_manager-0.1.0/tempit/cli.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+
+"""CLI module for the tempit application."""
+
+import argparse
+import logging
+import sys
+
+from tempit.core import TempitManager
+
+
+def main() -> int:
+    """Main CLI entry point for the Tempit application."""
+    # Set up basic logging
+    logging.basicConfig(level=logging.WARNING, format="%(levelname)s: %(message)s")
+
+    parser = argparse.ArgumentParser(description="Manage temporary directories.")
+    parser.add_argument("-c", "--create", nargs="?", const="tempit",
+                        help="Create a new temporary directory.")
+    parser.add_argument("-init", "--init", type=str,
+                        help="Initialize Tempit in the current shell.")
+    parser.add_argument("-l", "--list", action="store_true",
+                        help="List all tracked temporary directories.")
+    parser.add_argument("-rm", "--remove", type=int,
+                        help="Remove a tracked temporary directory by its number.")
+    parser.add_argument("--clean-all", action="store_true",
+                        help="Remove all tracked temporary directories.")
+    parser.add_argument("-v", "--verbose", action="store_true",
+                        help="Enable verbose logging.")
+    args = parser.parse_args()
+
+    # Adjust logging level if verbose
+    if args.verbose:
+        logging.getLogger().setLevel(logging.INFO)
+
+    try:
+        manager = TempitManager()
+
+        if args.init:
+            manager.init_shell(args.init)
+        elif args.create:
+            print(manager.create(args.create))
+        elif args.list:
+            manager.print_directories()
+        elif args.remove:
+            success = manager.remove(args.remove)
+            if not success:
+                return 1
+        elif args.clean_all:
+            manager.clean_all_directories()
+        else:
+            parser.print_help()
+    except (IOError, OSError) as e:
+        logging.error("An error occurred: %s", e)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tempit_manager-0.1.0/tempit/core.py

@@ -0,0 +1,89 @@
+"""Core module for the tempit application."""
+
+import logging
+from pathlib import Path
+
+from tempit.render import DirectoryRenderer
+from tempit.services import DirectoryService
+from tempit.storage import DirectoryStorage
+
+
+class TempitManager:
+    """Main manager class for temporary directory operations."""
+
+    def __init__(self, storage_file: Path = Path("/tmp/tempit_dirs.json")):
+        """Initialize the TempitManager with dependency injection."""
+        self.logger = logging.getLogger(__name__)
+
+        self.storage = DirectoryStorage(storage_file)
+        self.service = DirectoryService(storage_file.parent)
+        self.renderer = DirectoryRenderer(self.storage, self.service)
+
+    def init_shell(self, shell: str) -> None:
+        """Initialize Tempit in the current shell."""
+        if shell in ["bash", "zsh"]:
+            init_script_path = Path(__file__).parent / "shell" / "init.sh"
+            try:
+                with init_script_path.open("r", encoding="utf-8") as f:
+                    print(f.read())
+            except FileNotFoundError:
+                self.logger.error("Error reading initialization script: %s", init_script_path)
+        else:
+            self.logger.error("Unsupported shell: %s", shell)
+
+    def create(self, prefix: str = "tempit") -> Path:
+        """Create a new temporary directory and track it."""
+        try:
+            dir_info = self.service.create_temp_directory(prefix)
+            self.storage.add_directory(dir_info)
+
+            self.logger.info("Created temporary directory: %s", dir_info.path)
+            return dir_info.path
+
+        except (IOError, OSError) as e:
+            self.logger.error("Error creating temporary directory: %s", e)
+            raise
+
+    def remove(self, number: int) -> bool:
+        """Remove a tracked temporary directory by its number."""
+
+        try:
+            dir_path = self.storage.get_path_by_number(number)
+            if dir_path is None:
+                return False
+
+            success = self.service.remove_directory(dir_path)
+
+            if success:
+                self.storage.remove_directory(dir_path)
+                self.logger.info("Removed temporary directory: %s", dir_path)
+                return True
+            return False
+
+        except (IOError, OSError) as e:
+            self.logger.error("Error removing temporary directory: %s", e)
+            return False
+
+    def print_directories(self) -> None:
+        """Print a formatted table of tracked temporary directories."""
+        directories = self.storage.get_existing_directories()
+        self.renderer.render_directory_list(directories)
+
+    def clean_all_directories(self) -> None:
+        """Remove all tracked temporary directories."""
+        directories = self.storage.get_existing_directories()
+
+        if not directories:
+            self.logger.warning("No temporary directories found.")
+            return
+
+        removed_count = 0
+        for dir_info in directories:
+            try:
+                if self.service.remove_directory(dir_info.path):
+                    removed_count += 1
+            except (IOError, OSError) as e:
+                self.logger.error("Error removing directory %s: %s", dir_info.path, e)
+
+        self.storage.clear_all()
+        self.logger.info("Removed %s temporary directories.", removed_count)

tempit_manager-0.1.0/tempit/models.py

@@ -0,0 +1,40 @@
+"""Data models for the tempit application."""
+
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict
+
+
+@dataclass
+class DirectoryInfo:
+    """Data model for temporary directory information."""
+
+    path: Path
+    created: datetime
+    prefix: str = "tempit"
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        data = asdict(self)
+        data["created"] = self.created.isoformat()
+        return data
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DirectoryInfo":
+        """Create instance from dictionary (JSON deserialization)."""
+        data = data.copy()
+        data["created"] = datetime.fromisoformat(data["created"])
+        data["path"] = Path(data["path"])
+        return cls(**data)
+
+
+@dataclass
+class DirectoryStats:
+    """Runtime statistics for a directory (not stored in JSON)."""
+
+    size_bytes: int
+    human_size: str
+    file_count: int
+    dir_count: int
+    age: str

tempit_manager-0.1.0/tempit/render.py

@@ -0,0 +1,188 @@
+"""Render directory information from JSON storage."""
+
+# mypy: disable-error-code="arg-type"
+import datetime
+from typing import List, Optional
+
+import humanize
+from tabulate import tabulate  # type: ignore[import-untyped]
+from termcolor import colored
+
+from tempit.models import DirectoryInfo, DirectoryStats
+from tempit.services import DirectoryService
+from tempit.storage import DirectoryStorage
+
+
+class DirectoryRenderer:
+    """Handles rendering of directory information from JSON storage."""
+
+    def __init__(self, storage: DirectoryStorage, service: DirectoryService):
+        """Initialize the renderer with storage and service dependencies."""
+        self.storage = storage
+        self.service = service
+
+    def get_headers(self) -> List[str]:
+        """Return formatted table headers for directory listings."""
+        return [
+            colored("#", "white", attrs=["bold"]),
+            colored("Name", "white", attrs=["bold"]),
+            colored("Path", "white", attrs=["bold"]),
+            colored("Size", "white", attrs=["bold"]),
+            colored("Created", "white", attrs=["bold"]),
+            colored("Age", "white", attrs=["bold"]),
+            colored("Contents", "white", attrs=["bold"]),
+        ]
+
+    def render_directory_list(
+        self, directories: List[DirectoryInfo], title: str = "Temporary Directories"
+    ) -> None:
+        """Render all directories from JSON storage."""
+
+        if not directories:
+            print(colored("No temporary directories found.", "yellow"))
+            return
+
+        table_data = []
+        for i, dir_info in enumerate(directories):
+            stats = self.service.calculate_directory_stats(dir_info)
+            if not stats:
+                continue
+            friendly_name = dir_info.prefix
+            row = self._create_table_row(dir_info, stats, i, friendly_name)
+            table_data.append(row)
+
+        self._print_table(table_data, self.get_headers(), title)
+
+    def _create_table_row(
+        self,
+        dir_info: DirectoryInfo,
+        stats: DirectoryStats,
+        index: int,
+        friendly_name: str,
+    ) -> List[str]:
+        """Create a formatted table row from directory info and stats."""
+        # Format creation date
+        created_str = dir_info.created.strftime("%Y-%m-%d %H:%M")
+
+        # Name column with color
+        name = colored(friendly_name, "cyan", attrs=["bold"])
+
+        # Size with color thresholds
+        size_color = "green"
+        if stats.size_bytes > 10 * 1024 * 1024:  # > 10MB
+            size_color = "yellow"
+        if stats.size_bytes > 100 * 1024 * 1024:  # > 100MB
+            size_color = "red"
+        human_size = colored(stats.human_size, size_color)
+
+        # Age with color
+        age_color = "green"
+        if "day" in stats.age or "month" in stats.age or "year" in stats.age:
+            age_color = "yellow"
+        colored_age = colored(stats.age, age_color)
+
+        # Contents info
+        contents_info = (
+            f"{colored(stats.file_count, 'blue')} files, "
+            f"{colored(stats.dir_count, 'blue')} dirs"
+        )
+
+        return [
+            colored(str(index + 1), "white", attrs=["bold"]),
+            name,
+            str(dir_info.path),
+            human_size,
+            created_str,
+            colored_age,
+            contents_info,
+        ]
+
+    def _print_table(
+        self, rows: List[List[str]], hdrs: List[str], title: Optional[str] = None
+    ) -> None:
+        """Print a nicely formatted table."""
+        if title:
+            print()
+            print(colored(title, "white", attrs=["bold"]))
+        print(
+            tabulate(
+                rows,
+                headers=hdrs,
+                tablefmt="rounded_grid",
+                numalign="center",
+            )
+        )
+        print()
+
+
+# Legacy functions for backward compatibility
+def headers() -> List[str]:
+    """Return formatted table headers for directory listings."""
+    return [
+        colored("#", "white", attrs=["bold"]),
+        colored("Name", "white", attrs=["bold"]),
+        colored("Path", "white", attrs=["bold"]),
+        colored("Size", "white", attrs=["bold"]),
+        colored("Created", "white", attrs=["bold"]),
+        colored("Age", "white", attrs=["bold"]),
+        colored("Contents", "white", attrs=["bold"]),
+    ]
+
+
+def row_from_info(info: dict, index: int, friendly_name: str) -> List[str]:
+    """Create a formatted row from directory info (legacy function).
+
+    Expected keys in info: path, human_size, created (datetime), file_count, dir_count, size
+    """
+    created: datetime.datetime = info["created"]
+    created_str = created.strftime("%Y-%m-%d %H:%M")
+
+    # Name column
+    name = colored(friendly_name, "cyan", attrs=["bold"])
+
+    # Size with color thresholds
+    size_color = "green"
+    if info["size"] > 10 * 1024 * 1024:  # > 10MB
+        size_color = "yellow"
+    if info["size"] > 100 * 1024 * 1024:  # > 100MB
+        size_color = "red"
+    human_size = colored(info["human_size"], size_color)  # type: ignore[arg-type]
+
+    # Age
+    age = humanize.naturaltime(datetime.datetime.now() - created)
+    age_color = "green"
+    if "day" in age or "month" in age or "year" in age:
+        age_color = "yellow"
+    colored_age = colored(age, age_color)  # type: ignore[arg-type]
+
+    # Contents
+    contents_info = (
+        f"{colored(info['file_count'], 'blue')} files, "
+        f"{colored(info['dir_count'], 'blue')} dirs"
+    )
+
+    return [
+        colored(str(index + 1), "white", attrs=["bold"]),
+        name,
+        info["path"],
+        human_size,
+        created_str,
+        colored_age,
+        contents_info,
+    ]
+
+
+def print_table(rows: List[List[str]], hdrs: List[str], title: Optional[str] = None) -> None:
+    """Print a nicely formatted table of directories."""
+    if title:
+        print()
+        print(colored(title, "white", attrs=["bold"]))
+    print(
+        tabulate(
+            rows,
+            headers=hdrs,
+            tablefmt="rounded_grid",
+            numalign="center",
+        )
+    )
+    print()

tempit_manager-0.1.0/tempit/services.py

@@ -0,0 +1,84 @@
+"""Service layer for directory operations and statistics."""
+
+import logging
+import shutil
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Tuple
+
+import humanize
+
+from tempit.models import DirectoryInfo, DirectoryStats
+
+
+class DirectoryService:
+    """Service for directory operations and statistics calculation."""
+
+    def __init__(self, temp_base_dir: Path = Path("/tmp")):
+        """Initialize the directory service."""
+        self.temp_base_dir = temp_base_dir
+        self.logger = logging.getLogger(__name__)
+
+    def create_temp_directory(self, prefix: str = "tempit") -> DirectoryInfo:
+        """Create a new temporary directory and return its info."""
+        try:
+            temp_dir = tempfile.mkdtemp(prefix=f"{prefix}_", dir=self.temp_base_dir)
+
+            return DirectoryInfo(
+                path=Path(temp_dir), created=datetime.now(), prefix=prefix
+            )
+        except (IOError, OSError) as e:
+            self.logger.error("Error creating temporary directory: %s", e)
+            raise
+
+    def remove_directory(self, path: Path) -> bool:
+        """Remove a directory from the filesystem."""
+        try:
+            if path.exists():
+                shutil.rmtree(path)
+                self.logger.info("Removed directory: %s", path)
+                return True
+            self.logger.warning("Directory does not exist: %s", path)
+            return False
+        except (IOError, OSError) as e:
+            self.logger.error("Error removing directory %s: %s", path, e)
+            return False
+
+    def calculate_directory_stats(self, directory_info: DirectoryInfo) -> DirectoryStats | None:
+        """Calculate runtime statistics for a directory."""
+        dir_path: Path = directory_info.path
+        if not dir_path.exists():
+            self.logger.warning("Directory does not exist: %s", dir_path)
+            return None
+
+        # Calculate size
+        total_size = self._get_directory_size(dir_path)
+        human_size = humanize.naturalsize(total_size, binary=True)
+
+        # Count files and directories
+        file_count, dir_count = self._count_directory_contents(dir_path)
+
+        # Calculate age
+        creation_time = directory_info.created
+        age = humanize.naturaltime(datetime.now() - creation_time)
+
+        return DirectoryStats(
+            size_bytes=total_size,
+            human_size=human_size,
+            file_count=file_count,
+            dir_count=dir_count,
+            age=age,
+        )
+
+    @staticmethod
+    def _get_directory_size(directory: Path) -> int:
+        """Get the total size of a directory in bytes."""
+        return sum(f.stat().st_size for f in directory.rglob("*") if f.is_file())
+
+    @staticmethod
+    def _count_directory_contents(directory: Path) -> Tuple[int, int]:
+        """Count files and subdirectories in a directory."""
+        files = sum(1 for f in directory.rglob("*") if f.is_file())
+        dirs = sum(1 for d in directory.rglob("*") if d.is_dir())
+        return files, dirs

tempit_manager-0.1.0/tempit/shell/init.sh

@@ -0,0 +1,40 @@
+__TEMPIT_EXE="$(command -v tempit)"
+
+if [[ -z "$__TEMPIT_EXE" ]]; then
+  echo "tempit: executable not found in PATH" >&2
+else
+  _tempit() {
+    # Allow `tempit init zsh` to work even after the function is defined.
+    if [[ "$1" == "init" ]]; then
+      command "$__TEMPIT_EXE" "$@"
+      return $?
+    fi
+    case "$1" in
+      create|-c)
+        shift
+        local __path
+        __path="$(command "$__TEMPIT_EXE" --create "$@")" || return $?
+        if [[ -n "$__path" && -d "$__path" ]]; then
+          cd "$__path"
+        fi
+        ;;
+      go|-g)
+        shift
+        local __path
+        __path="$(command "$__TEMPIT_EXE" --get "$@")" || return $?
+        if [[ -n "$__path" && -d "$__path" ]]; then
+          cd "$__path"
+        fi
+        ;;
+      *)
+        command "$__TEMPIT_EXE" "$@"
+        ;;
+    esac
+  }
+
+    # Aliases
+    alias tempc="_tempit create"
+    alias tempg="_tempit go"
+    alias templ="$__TEMPIT_EXE --list"
+
+fi

tempit_manager-0.1.0/tempit/storage.py

@@ -0,0 +1,89 @@
+"""Storage layer for persisting directory information in JSON format."""
+
+import json
+import logging
+from pathlib import Path
+from typing import List
+
+from tempit.models import DirectoryInfo
+
+
+class DirectoryStorage:
+    """Handles JSON-based persistence of directory information."""
+
+    def __init__(self, storage_file: Path = Path("/tmp/tempit_dirs.json")):
+        """Initialize the storage with a JSON file path."""
+        self.storage_file = storage_file
+        self.logger = logging.getLogger(__name__)
+        self._ensure_storage_file()
+
+    def _ensure_storage_file(self) -> None:
+        """Ensure the storage file and its parent directory exist."""
+        self.storage_file.parent.mkdir(parents=True, exist_ok=True)
+        if not self.storage_file.exists():
+            self._write_directories([])
+
+    def _read_directories(self) -> List[DirectoryInfo]:
+        """Read all directories from the JSON storage file."""
+        try:
+            with open(self.storage_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return [DirectoryInfo.from_dict(item) for item in data]
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            self.logger.warning("Error reading storage file: %s", e)
+            return []
+
+    def _write_directories(self, directories: List[DirectoryInfo]) -> None:
+        """Write all directories to the JSON storage file."""
+        try:
+            data = [dir_info.to_dict() for dir_info in directories]
+            with open(self.storage_file, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, default=str)
+        except (IOError, TypeError) as e:
+            self.logger.error("Error writing to storage file: %s", e)
+            raise
+
+    def add_directory(self, directory_info: DirectoryInfo) -> None:
+        """Add a new directory to storage."""
+        directories = self._read_directories()
+        directories.append(directory_info)
+        self._write_directories(directories)
+
+    def get_existing_directories(self) -> List[DirectoryInfo]:
+        """Get only directories that still exist on the filesystem."""
+        all_dirs = self._read_directories()
+        existing_dirs = [d for d in all_dirs if d.path.exists()]
+
+        # Update storage if some directories no longer exist
+        if len(existing_dirs) != len(all_dirs):
+            self._write_directories(existing_dirs)
+            self.logger.info("Refreshed directories list.")
+
+        return existing_dirs
+
+    def get_path_by_number(self, number: int) -> Path | None:
+        """Get the path of a tracked temporary directory by its number."""
+        directories = self.get_existing_directories()
+        if not directories or not 1 <= number <= len(directories):
+            self.logger.error("Invalid directory number: %s", number)
+            return None
+        return directories[number - 1].path
+
+    def remove_directory(self, path: Path) -> bool:
+        """Remove a directory from storage by path."""
+        directories = self._read_directories()
+        directories = [d for d in directories if d.path != path]
+        self._write_directories(directories)
+        return True
+
+    def find_directory_by_path(self, path: Path) -> DirectoryInfo | None:
+        """Find a directory by its path."""
+        directories = self._read_directories()
+        for directory in directories:
+            if directory.path == path:
+                return directory
+        return None
+
+    def clear_all(self) -> None:
+        """Remove all directories from storage."""
+        self._write_directories([])