docs: refactor warning

README.md

@@ -1,56 +1,46 @@
 # Skywipe
 
-Skywipe is a work-in-progress Python 3.13+ CLI that helps you wipe data from your Bluesky account using the AT Protocol (`atproto` library).
+Skywipe is a work-in-progress Python 3.13+ CLI that helps you wipe data from your Bluesky account using the AT Protocol SDK.
 
-## Warning
+**Warning:** This tool performs _**destructive operations**_.
 
-This tool performs destructive operations. Only use it if you intend to erase data from your Bluesky account.
+Only use it if you intend to permanently erase data from your Bluesky account.
 
 ## Requirements
 
-- Python 3.13+
-- [`atproto`](https://atproto.blue/en/latest/)
-- [`uv`](https://github.com/astral-sh/uv) for dependency and virtual environment management
+Check [pyproject.toml](pyproject.toml).
 
-## Setup
+You can use `uv` to install dependencies:
 
 ```bash
 git clone https://git.kharec.info/Kharec/skywipe.git
 cd skywipe
-uv sync  # creates a local virtualenv and installs dependencies
+uv sync
 ```
 
 ## How to run
 
-When installation will be worked out, you'll be able to :
-
-```bash
-skywipe all            # target everything
-skywipe configure      # create configuration
-skywipe posts          # only posts
-skywipe medias         # only posts with medias
-skywipe likes          # only likes
-skywipe reposts        # only reposts
-skywipe follows        # only follows
-```
-
 While it's being developed, you can use the tool using `uv` :
 
 ```bash
-uv run main.py all            # target everything
-uv run main.py configure      # create configuration
-uv run main.py posts          # only posts
-uv run main.py medias         # only posts with medias
-uv run main.py likes          # only likes
-uv run main.py reposts        # only reposts
-uv run main.py follows        # only follows
+uv run python -m skywipe.cli all            # target everything
+uv run python -m skywipe.cli configure      # create configuration
+uv run python -m skywipe.cli posts          # delete posts
+uv run python -m skywipe.cli medias         # delete posts with medias
+uv run python -m skywipe.cli likes          # undo likes
+uv run python -m skywipe.cli reposts        # undo reposts
+uv run python -m skywipe.cli quotes         # delete quotes
+uv run python -m skywipe.cli follows        # unfollow all
+uv run python -m skywipe.cli bookmarks      # delete bookmarks
 ```
 
-### Configuration
+Use the `--yes` flag to skip the confirmation prompt and proceed with the operation.
 
-If you run the tool for the first time, it will prompt you to use `skywipe configure` to create the configuration file, which is located in `~/.config/skywipe/`.
+A log of the operations will be saved in `~/.cache/skywipe/skywipe.log`.
 
-It looks like this :
+## Configuration
+
+If you run the tool for the first time, it will prompt you to use `skywipe configure` to create the configuration file, which is located in `~/.config/skywipe/config.yml` :
 
 ```yaml
 handle: your_handle
@@ -64,17 +54,20 @@ BE SURE TO USE A [BLUESKY APP PASSWORD](https://blueskyfeeds.com/faq-app-passwor
 
 ## Roadmap
 
-- [ ] build cli parameter management
-- [ ] handle configuration logic
-- [ ] sign in to at protocol
-- [ ] delete posts in groups
-- [ ] only delete posts with media
-- [ ] remove likes
-- [ ] remove reposts
-- [ ] unfollow accounts
-- [ ] make `all` run the other commands
-- [ ] add simple progress and logging
-- [ ] add safeguards like confirmations and clear dry-run info
+- [x] build cli parameter management
+- [x] handle configuration logic
+- [x] sign in to at protocol
+- [x] delete posts in batch
+- [x] only delete posts with media
+- [x] undo likes
+- [x] undo reposts
+- [x] delete quotes
+- [x] unfollow accounts
+- [x] remove bookmarks
+- [x] make `all` run the other commands
+- [x] add simple progress and logging
+- [x] add safeguards (confirmation, dry-run flag)
+- [ ] decent code architecture
 - [ ] installation and run process
 
 ## License

pyproject.toml

@@ -1,9 +1,10 @@
 [project]
 name = "skywipe"
 version = "0.1.0"
-description = "Clean your bluesky account with style"
+description = "Clean your bluesky account"
 readme = "README.md"
 requires-python = ">=3.13"
-dependencies = [
-    "atproto>=0.0.65",
-]
+dependencies = ["atproto>=0.0.65", "pyyaml>=6.0"]
+
+[project.scripts]
+skywipe = "skywipe.cli:main"

skywipe/auth.py

@@ -0,0 +1,28 @@
+"""Authentication module for Skywipe"""
+
+from atproto import Client
+from .configure import Configuration
+
+
+class Auth:
+    def __init__(self):
+        self.config = Configuration()
+        self.client = None
+
+    def login(self) -> Client:
+        config_data = self.config.load()
+
+        handle = config_data.get("handle")
+        password = config_data.get("password")
+
+        if not handle or not password:
+            raise ValueError(
+                "handle and password must be set in configuration")
+
+        self.client = Client()
+        self.client.login(handle, password)
+
+        return self.client
+
+    def is_logged(self) -> bool:
+        return bool(getattr(self.client, "me", None))

skywipe/bookmarks.py

@@ -0,0 +1,78 @@
+"""Bookmark deletion module for Skywipe"""
+
+import time
+from atproto import models
+from .auth import Auth
+from .configure import Configuration
+from .logger import get_logger, ProgressTracker
+
+
+def delete_bookmarks():
+    logger = get_logger()
+    auth = Auth()
+    client = auth.login()
+    config = Configuration()
+    config_data = config.load()
+
+    batch_size = config_data.get("batch_size", 10)
+    delay = config_data.get("delay", 1)
+
+    logger.info(
+        f"Starting bookmark deletion with batch_size={batch_size}, delay={delay}s")
+
+    cursor = None
+    total_deleted = 0
+    batch_num = 0
+    progress = ProgressTracker(operation="Deleting bookmarks")
+
+    while True:
+        batch_num += 1
+        get_params = models.AppBskyBookmarkGetBookmarks.Params(
+            limit=batch_size,
+            cursor=cursor
+        )
+
+        response = client.app.bsky.bookmark.get_bookmarks(params=get_params)
+
+        bookmarks = response.bookmarks
+        if not bookmarks:
+            break
+
+        progress.batch(batch_num, len(bookmarks))
+
+        for bookmark in bookmarks:
+            try:
+                bookmark_uri = None
+                if hasattr(bookmark, "uri"):
+                    bookmark_uri = bookmark.uri
+                else:
+                    for attr_name in ("subject", "record", "post", "item"):
+                        if hasattr(bookmark, attr_name):
+                            nested = getattr(bookmark, attr_name)
+                            if hasattr(nested, "uri"):
+                                bookmark_uri = nested.uri
+                                break
+
+                if not bookmark_uri:
+                    logger.debug("Skipping bookmark: unable to find uri")
+                    continue
+
+                delete_data = models.AppBskyBookmarkDeleteBookmark.Data(
+                    uri=bookmark_uri
+                )
+                client.app.bsky.bookmark.delete_bookmark(data=delete_data)
+                total_deleted += 1
+                progress.update(1)
+                logger.debug(f"Deleted bookmark: {bookmark_uri}")
+            except Exception as e:
+                bookmark_uri = getattr(bookmark, "uri", "unknown")
+                logger.error(f"Error deleting bookmark {bookmark_uri}: {e}")
+
+        cursor = response.cursor
+        if not cursor:
+            break
+
+        if delay > 0:
+            time.sleep(delay)
+
+    logger.info(f"Deleted {total_deleted} bookmarks.")

skywipe/cli.py

@@ -0,0 +1,76 @@
+"""Main entry point for Skywipe"""
+
+import sys
+import argparse
+from pathlib import Path
+
+from .commands import registry
+from .configure import Configuration
+from .logger import setup_logger
+
+
+def create_parser():
+    commands = registry.get_all_commands()
+
+    parser = argparse.ArgumentParser(
+        description="Clean your bluesky account with style.",
+        epilog="WARNING: This tool performs destructive operations. Only use it if you intend to erase data from your Bluesky account."
+    )
+
+    parser.add_argument(
+        "--yes",
+        action="store_true",
+        help="Skip confirmation prompt and proceed with destructive operations"
+    )
+
+    subparsers = parser.add_subparsers(
+        dest="command",
+        help="Command to execute",
+        metavar="COMMAND",
+        required=True
+    )
+
+    for cmd, help_text in commands.items():
+        subparsers.add_parser(cmd, help=help_text)
+
+    return parser
+
+
+def require_config():
+    config = Configuration()
+    if not config.exists():
+        logger = setup_logger(verbose=False)
+        logger.error("Configuration file not found.")
+        logger.error("You must run 'skywipe configure' first.")
+        sys.exit(1)
+
+
+def main():
+    parser = create_parser()
+    args = parser.parse_args()
+
+    if registry.requires_config(args.command):
+        require_config()
+        config = Configuration()
+        config_data = config.load()
+        verbose = config_data.get("verbose", False)
+        log_file = Path.home() / ".cache" / "skywipe" / "skywipe.log"
+        setup_logger(verbose=verbose, log_file=log_file)
+    else:
+        setup_logger(verbose=False)
+
+    try:
+        registry.execute(
+            args.command, skip_confirmation=getattr(args, "yes", False))
+    except ValueError as e:
+        logger = setup_logger(verbose=False)
+        logger.error(f"{e}")
+        sys.exit(1)
+    except Exception as e:
+        logger = setup_logger(verbose=False)
+        logger.error(f"Unexpected error: {e}", exc_info=True)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

skywipe/commands.py

@@ -0,0 +1,130 @@
+"""Command implementations for Skywipe"""
+
+from typing import Callable, Dict, Optional
+from .configure import Configuration
+from .posts import delete_all_posts
+from .medias import delete_posts_with_medias
+from .likes import undo_likes
+from .reposts import undo_reposts
+from .quotes import delete_quotes_posts
+from .follows import unfollow_all
+from .bookmarks import delete_bookmarks
+from .logger import get_logger
+from .safeguard import require_confirmation
+
+
+CommandHandler = Callable[..., None]
+
+
+class CommandRegistry:
+    def __init__(self):
+        self._commands = {}
+        self._help_texts = {}
+        self._requires_config = {}
+
+    def register(
+        self,
+        name: str,
+        handler: CommandHandler,
+        help_text: str,
+        requires_config: bool = True
+    ):
+        self._commands[name] = handler
+        self._help_texts[name] = help_text
+        self._requires_config[name] = requires_config
+
+    def get_handler(self, name: str) -> Optional[CommandHandler]:
+        return self._commands.get(name)
+
+    def get_help_text(self, name: str) -> Optional[str]:
+        return self._help_texts.get(name)
+
+    def requires_config(self, name: str) -> bool:
+        return self._requires_config.get(name, True)
+
+    def get_all_commands(self) -> Dict[str, str]:
+        return self._help_texts.copy()
+
+    def execute(self, name: str, skip_confirmation: bool = False):
+        handler = self.get_handler(name)
+        if handler:
+            if name == "configure":
+                handler()
+            else:
+                handler(skip_confirmation)
+        else:
+            raise ValueError(f"Unknown command: {name}")
+
+
+registry = CommandRegistry()
+
+
+def run_configure():
+    config = Configuration()
+    config.create()
+
+
+def run_posts(skip_confirmation: bool = False):
+    require_confirmation("delete all posts", skip_confirmation)
+    delete_all_posts()
+
+
+def run_medias(skip_confirmation: bool = False):
+    require_confirmation("delete all posts with media", skip_confirmation)
+    delete_posts_with_medias()
+
+
+def run_likes(skip_confirmation: bool = False):
+    require_confirmation("undo all likes", skip_confirmation)
+    undo_likes()
+
+
+def run_reposts(skip_confirmation: bool = False):
+    require_confirmation("undo all reposts", skip_confirmation)
+    undo_reposts()
+
+
+def run_quotes(skip_confirmation: bool = False):
+    require_confirmation("delete all quote posts", skip_confirmation)
+    delete_quotes_posts()
+
+
+def run_follows(skip_confirmation: bool = False):
+    require_confirmation("unfollow all accounts", skip_confirmation)
+    unfollow_all()
+
+
+def run_bookmarks(skip_confirmation: bool = False):
+    require_confirmation("delete all bookmarks", skip_confirmation)
+    delete_bookmarks()
+
+
+def run_all(skip_confirmation: bool = False):
+    logger = get_logger()
+    require_confirmation(
+        "run all cleanup commands (posts, likes, reposts, follows, bookmarks)", skip_confirmation)
+
+    commands = ["posts", "likes", "reposts", "follows", "bookmarks"]
+
+    logger.info("Running all cleanup commands...")
+    for cmd in commands:
+        try:
+            logger.info(f"Starting command: {cmd}")
+            registry.execute(cmd, skip_confirmation=True)
+            logger.info(f"Completed command: {cmd}")
+        except Exception as e:
+            logger.error(f"Error running '{cmd}': {e}", exc_info=True)
+            continue
+    logger.info("All commands completed.")
+
+
+registry.register("configure", run_configure,
+                  "create configuration", requires_config=False)
+registry.register("posts", run_posts, "only posts")
+registry.register("medias", run_medias, "only posts with medias")
+registry.register("likes", run_likes, "only likes")
+registry.register("reposts", run_reposts, "only reposts")
+registry.register("quotes", run_quotes, "only quotes")
+registry.register("follows", run_follows, "only follows")
+registry.register("bookmarks", run_bookmarks, "only bookmarks")
+registry.register("all", run_all, "target everything")

skywipe/configure.py

@@ -0,0 +1,64 @@
+"""Core configuration module for Skywipe"""
+
+import getpass
+from pathlib import Path
+import yaml
+from .logger import setup_logger, get_logger
+
+
+class Configuration:
+    def __init__(self):
+        self.config_file = Path.home() / ".config" / "skywipe" / "config.yml"
+
+    def exists(self) -> bool:
+        return self.config_file.exists()
+
+    def create(self):
+        logger = setup_logger(verbose=False)
+        if self.exists():
+            overwrite = input(
+                "Configuration already exists. Overwrite? (y/N): ").strip().lower()
+            if overwrite not in ("y", "yes"):
+                logger.info("Configuration creation cancelled.")
+                return
+
+        config_dir = self.config_file.parent
+        config_dir.mkdir(parents=True, exist_ok=True)
+
+        print("Skywipe Configuration")
+        print("=" * 50)
+        handle = input("Bluesky handle: ").strip()
+        password = getpass.getpass("Bluesky app password: ").strip()
+        batch_size = input("Batch size (default: 10): ").strip() or "10"
+        delay = input(
+            "Delay between batches in seconds (default: 1): ").strip() or "1"
+        verbose_input = input(
+            "Verbose mode (y/n, default: y): ").strip().lower() or "y"
+        verbose = verbose_input in ("y", "yes", "true", "1")
+
+        try:
+            batch_size = int(batch_size)
+            delay = int(delay)
+        except ValueError:
+            logger.error("batch_size and delay must be integers")
+            return
+
+        config_data = {
+            "handle": handle,
+            "password": password,
+            "batch_size": batch_size,
+            "delay": delay,
+            "verbose": verbose
+        }
+
+        with open(self.config_file, "w") as f:
+            yaml.dump(config_data, f, default_flow_style=False)
+
+        logger.info(f"Configuration saved to {self.config_file}")
+
+    def load(self) -> dict:
+        if not self.exists():
+            raise FileNotFoundError(
+                f"Configuration file not found: {self.config_file}")
+        with open(self.config_file, "r") as f:
+            return yaml.safe_load(f)

skywipe/follows.py

@@ -0,0 +1,73 @@
+"""Follow undoing module for Skywipe"""
+
+import time
+from atproto import models
+from .auth import Auth
+from .configure import Configuration
+from .logger import get_logger, ProgressTracker
+
+
+FOLLOW_COLLECTION = "app.bsky.graph.follow"
+
+
+def unfollow_all():
+    logger = get_logger()
+    auth = Auth()
+    client = auth.login()
+    config = Configuration()
+    config_data = config.load()
+
+    batch_size = config_data.get("batch_size", 10)
+    delay = config_data.get("delay", 1)
+
+    logger.info(
+        f"Starting unfollow operation with batch_size={batch_size}, delay={delay}s")
+
+    did = client.me.did
+    cursor = None
+    total_unfollowed = 0
+    batch_num = 0
+    progress = ProgressTracker(operation="Unfollowing accounts")
+
+    while True:
+        batch_num += 1
+        list_params = models.ComAtprotoRepoListRecords.Params(
+            repo=did,
+            collection=FOLLOW_COLLECTION,
+            limit=batch_size,
+            cursor=cursor
+        )
+
+        response = client.com.atproto.repo.list_records(params=list_params)
+
+        records = response.records
+        if not records:
+            break
+
+        progress.batch(batch_num, len(records))
+
+        for record in records:
+            try:
+                record_uri = record.uri
+                rkey = record_uri.rsplit("/", 1)[-1]
+                delete_data = {
+                    "repo": did,
+                    "collection": FOLLOW_COLLECTION,
+                    "rkey": rkey
+                }
+                client.com.atproto.repo.delete_record(data=delete_data)
+                total_unfollowed += 1
+                progress.update(1)
+                logger.debug(f"Unfollowed: {record_uri}")
+            except Exception as e:
+                record_uri = getattr(record, "uri", "unknown")
+                logger.error(f"Error unfollowing {record_uri}: {e}")
+
+        cursor = response.cursor
+        if not cursor:
+            break
+
+        if delay > 0:
+            time.sleep(delay)
+
+    logger.info(f"Unfollowed {total_unfollowed} accounts.")

skywipe/likes.py

@@ -0,0 +1,73 @@
+"""Like undoing module for Skywipe"""
+
+import time
+from atproto import models
+from .auth import Auth
+from .configure import Configuration
+from .logger import get_logger, ProgressTracker
+
+
+LIKE_COLLECTION = "app.bsky.feed.like"
+
+
+def undo_likes():
+    logger = get_logger()
+    auth = Auth()
+    client = auth.login()
+    config = Configuration()
+    config_data = config.load()
+
+    batch_size = config_data.get("batch_size", 10)
+    delay = config_data.get("delay", 1)
+
+    logger.info(
+        f"Starting like deletion with batch_size={batch_size}, delay={delay}s")
+
+    did = client.me.did
+    cursor = None
+    total_undone = 0
+    batch_num = 0
+    progress = ProgressTracker(operation="Undoing likes")
+
+    while True:
+        batch_num += 1
+        list_params = models.ComAtprotoRepoListRecords.Params(
+            repo=did,
+            collection=LIKE_COLLECTION,
+            limit=batch_size,
+            cursor=cursor
+        )
+
+        response = client.com.atproto.repo.list_records(params=list_params)
+
+        records = response.records
+        if not records:
+            break
+
+        progress.batch(batch_num, len(records))
+
+        for record in records:
+            try:
+                record_uri = record.uri
+                rkey = record_uri.rsplit("/", 1)[-1]
+                delete_data = {
+                    "repo": did,
+                    "collection": LIKE_COLLECTION,
+                    "rkey": rkey
+                }
+                client.com.atproto.repo.delete_record(data=delete_data)
+                total_undone += 1
+                progress.update(1)
+                logger.debug(f"Undone like: {record_uri}")
+            except Exception as e:
+                record_uri = getattr(record, "uri", "unknown")
+                logger.error(f"Error undoing like {record_uri}: {e}")
+
+        cursor = response.cursor
+        if not cursor:
+            break
+
+        if delay > 0:
+            time.sleep(delay)
+
+    logger.info(f"Undone {total_undone} likes.")

skywipe/logger.py

@@ -0,0 +1,73 @@
+"""Centralized logging module for Skywipe"""
+
+import logging
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+class ProgressTracker:
+    def __init__(self, operation: str = "Processing"):
+        self.current = 0
+        self.operation = operation
+
+    def update(self, count: int = 1):
+        self.current += count
+
+    def batch(self, batch_num: int, batch_size: int, total_batches: Optional[int] = None):
+        logger = logging.getLogger("skywipe.progress")
+        if total_batches:
+            logger.info(
+                f"{self.operation} - batch {batch_num}/{total_batches} ({batch_size} items)"
+            )
+        else:
+            logger.info(
+                f"{self.operation} - batch {batch_num} ({batch_size} items)")
+
+
+class LevelFilter(logging.Filter):
+    def __init__(self, min_level: int, max_level: int):
+        super().__init__()
+        self.min_level = min_level
+        self.max_level = max_level
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return self.min_level <= record.levelno <= self.max_level
+
+
+def setup_logger(verbose: bool = False, log_file: Optional[Path] = None) -> logging.Logger:
+    logger = logging.getLogger("skywipe")
+    logger.setLevel(logging.DEBUG if verbose else logging.INFO)
+
+    if logger.handlers:
+        return logger
+
+    formatter = logging.Formatter(fmt="%(levelname)s: %(message)s")
+
+    info_handler = logging.StreamHandler(sys.stdout)
+    info_handler.setLevel(logging.DEBUG if verbose else logging.INFO)
+    info_handler.addFilter(LevelFilter(logging.DEBUG, logging.INFO))
+    info_handler.setFormatter(formatter)
+    logger.addHandler(info_handler)
+
+    error_handler = logging.StreamHandler(sys.stderr)
+    error_handler.setLevel(logging.WARNING)
+    error_handler.setFormatter(formatter)
+    logger.addHandler(error_handler)
+
+    if log_file:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(log_file, encoding="utf-8")
+        file_handler.setLevel(logging.DEBUG)
+        file_formatter = logging.Formatter(
+            fmt="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S"
+        )
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+
+    return logger
+
+
+def get_logger() -> logging.Logger:
+    return logging.getLogger("skywipe")

skywipe/medias.py

@@ -0,0 +1,95 @@
+"""Media post deletion module for Skywipe"""
+
+import time
+from .auth import Auth
+from .configure import Configuration
+from .logger import get_logger, ProgressTracker
+
+
+def delete_posts_with_medias():
+    logger = get_logger()
+    auth = Auth()
+    client = auth.login()
+    config = Configuration()
+    config_data = config.load()
+
+    batch_size = config_data.get("batch_size", 10)
+    delay = config_data.get("delay", 1)
+
+    logger.info(
+        f"Starting media post deletion with batch_size={batch_size}, delay={delay}s")
+
+    did = client.me.did
+    cursor = None
+    total_deleted = 0
+    batch_num = 0
+    progress = ProgressTracker(operation="Deleting posts with media")
+
+    while True:
+        batch_num += 1
+        response = client.get_author_feed(
+            actor=did, limit=batch_size, cursor=cursor)
+
+        posts = response.feed
+        if not posts:
+            break
+
+        progress.batch(batch_num, len(posts))
+
+        for post in posts:
+            post_record = post.post
+
+            embed = getattr(post_record, 'embed', None)
+            has_media = False
+            if embed:
+                embed_type = getattr(embed, 'py_type', None)
+                media_types = {
+                    'app.bsky.embed.images',
+                    'app.bsky.embed.video',
+                    'app.bsky.embed.external'
+                }
+
+                if embed_type:
+                    embed_type_base = embed_type.split('#')[0]
+
+                    if embed_type_base in media_types:
+                        has_media = True
+
+                    if not has_media and embed_type_base in ('app.bsky.embed.recordWithMedia', 'app.bsky.embed.record_with_media'):
+                        media = getattr(embed, 'media', None)
+                        if media:
+                            media_type = getattr(media, 'py_type', None)
+                            if media_type:
+                                media_type_base = media_type.split('#')[0]
+                                if media_type_base in media_types:
+                                    has_media = True
+
+                if not has_media:
+                    for attr in ('images', 'video', 'external'):
+                        if hasattr(embed, attr):
+                            has_media = True
+                            break
+                        if isinstance(embed, dict) and embed.get(attr):
+                            has_media = True
+                            break
+
+            if not has_media:
+                logger.debug(f"Skipping post without media: {post_record.uri}")
+                continue
+
+            try:
+                client.delete_post(post_record.uri)
+                total_deleted += 1
+                progress.update(1)
+                logger.debug(f"Deleted post with media: {post_record.uri}")
+            except Exception as e:
+                logger.error(f"Error deleting post {post_record.uri}: {e}")
+
+        cursor = response.cursor
+        if not cursor:
+            break
+
+        if delay > 0:
+            time.sleep(delay)
+
+    logger.info(f"Deleted {total_deleted} posts with media.")

skywipe/posts.py

@@ -0,0 +1,59 @@
+"""Post deletion module for Skywipe"""
+
+import time
+from .auth import Auth
+from .configure import Configuration
+from .logger import get_logger, ProgressTracker
+
+
+def delete_all_posts():
+    logger = get_logger()
+    auth = Auth()
+    client = auth.login()
+    config = Configuration()
+    config_data = config.load()
+
+    batch_size = config_data.get("batch_size", 10)
+    delay = config_data.get("delay", 1)
+
+    logger.info(
+        f"Starting post deletion with batch_size={batch_size}, delay={delay}s")
+
+    did = client.me.did
+    cursor = None
+    total_deleted = 0
+    batch_num = 0
+    progress = ProgressTracker(operation="Deleting posts")
+
+    while True:
+        batch_num += 1
+        if cursor:
+            response = client.get_author_feed(
+                actor=did, limit=batch_size, cursor=cursor)
+        else:
+            response = client.get_author_feed(actor=did, limit=batch_size)
+
+        posts = response.feed
+        if not posts:
+            break
+
+        post_uris = [post.post.uri for post in posts]
+        progress.batch(batch_num, len(post_uris))
+
+        for uri in post_uris:
+            try:
+                client.delete_post(uri)
+                total_deleted += 1
+                progress.update(1)
+                logger.debug(f"Deleted post: {uri}")
+            except Exception as e:
+                logger.error(f"Error deleting post {uri}: {e}")
+
+        cursor = response.cursor
+        if not cursor:
+            break
+
+        if delay > 0:
+            time.sleep(delay)
+
+    logger.info(f"Deleted {total_deleted} posts.")

skywipe/quotes.py

@@ -0,0 +1,77 @@
+"""Quote post deletion module for Skywipe"""
+
+import time
+from .auth import Auth
+from .configure import Configuration
+from .logger import get_logger, ProgressTracker
+
+
+def delete_quotes_posts():
+    logger = get_logger()
+    auth = Auth()
+    client = auth.login()
+    config = Configuration()
+    config_data = config.load()
+
+    batch_size = config_data.get("batch_size", 10)
+    delay = config_data.get("delay", 1)
+
+    logger.info(f"Starting quote post deletion with batch_size={batch_size}, delay={delay}s")
+
+    did = client.me.did
+    cursor = None
+    total_deleted = 0
+    batch_num = 0
+    progress = ProgressTracker(operation="Deleting quote posts")
+
+    while True:
+        batch_num += 1
+        response = client.get_author_feed(
+            actor=did, limit=batch_size, cursor=cursor)
+
+        posts = response.feed
+        if not posts:
+            break
+
+        progress.batch(batch_num, len(posts))
+
+        for post in posts:
+            post_record = post.post
+
+            embed = getattr(post_record, 'embed', None)
+            has_quote = False
+            if embed:
+                embed_type = getattr(embed, 'py_type', None)
+                if embed_type:
+                    embed_type_base = embed_type.split('#')[0]
+                    quote_types = {
+                        'app.bsky.embed.record',
+                        'app.bsky.embed.recordWithMedia',
+                        'app.bsky.embed.record_with_media'
+                    }
+                    if embed_type_base in quote_types:
+                        has_quote = True
+                
+                if not has_quote and (hasattr(embed, 'record') or (isinstance(embed, dict) and embed.get('record'))):
+                    has_quote = True
+
+            if not has_quote:
+                logger.debug(f"Skipping post without quote: {post_record.uri}")
+                continue
+
+            try:
+                client.delete_post(post_record.uri)
+                total_deleted += 1
+                progress.update(1)
+                logger.debug(f"Deleted quote post: {post_record.uri}")
+            except Exception as e:
+                logger.error(f"Error deleting quote post {post_record.uri}: {e}")
+
+        cursor = response.cursor
+        if not cursor:
+            break
+
+        if delay > 0:
+            time.sleep(delay)
+
+    logger.info(f"Deleted {total_deleted} quote posts.")

skywipe/reposts.py

@@ -0,0 +1,73 @@
+"""Repost undoing module for Skywipe"""
+
+import time
+from atproto import models
+from .auth import Auth
+from .configure import Configuration
+from .logger import get_logger, ProgressTracker
+
+
+REPOST_COLLECTION = "app.bsky.feed.repost"
+
+
+def undo_reposts():
+    logger = get_logger()
+    auth = Auth()
+    client = auth.login()
+    config = Configuration()
+    config_data = config.load()
+
+    batch_size = config_data.get("batch_size", 10)
+    delay = config_data.get("delay", 1)
+
+    logger.info(
+        f"Starting repost deletion with batch_size={batch_size}, delay={delay}s")
+
+    did = client.me.did
+    cursor = None
+    total_undone = 0
+    batch_num = 0
+    progress = ProgressTracker(operation="Undoing reposts")
+
+    while True:
+        batch_num += 1
+        list_params = models.ComAtprotoRepoListRecords.Params(
+            repo=did,
+            collection=REPOST_COLLECTION,
+            limit=batch_size,
+            cursor=cursor
+        )
+
+        response = client.com.atproto.repo.list_records(params=list_params)
+
+        records = response.records
+        if not records:
+            break
+
+        progress.batch(batch_num, len(records))
+
+        for record in records:
+            try:
+                record_uri = record.uri
+                rkey = record_uri.rsplit("/", 1)[-1]
+                delete_data = {
+                    "repo": did,
+                    "collection": REPOST_COLLECTION,
+                    "rkey": rkey
+                }
+                client.com.atproto.repo.delete_record(data=delete_data)
+                total_undone += 1
+                progress.update(1)
+                logger.debug(f"Undone repost: {record_uri}")
+            except Exception as e:
+                record_uri = getattr(record, "uri", "unknown")
+                logger.error(f"Error undoing repost {record_uri}: {e}")
+
+        cursor = response.cursor
+        if not cursor:
+            break
+
+        if delay > 0:
+            time.sleep(delay)
+
+    logger.info(f"Undone {total_undone} reposts.")

skywipe/safeguard.py

@@ -0,0 +1,27 @@
+"""Safeguard module for Skywipe"""
+
+import sys
+from .logger import get_logger
+
+
+CONFIRM_RESPONSES = {"yes", "y"}
+
+
+def require_confirmation(operation: str, skip_confirmation: bool = False) -> None:
+    if skip_confirmation:
+        return
+
+    logger = get_logger()
+    logger.warning(f"This will {operation}")
+    logger.warning("This operation is DESTRUCTIVE and cannot be undone!")
+
+    try:
+        response = input(
+            "Are you sure you want to continue? (y/N): ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        logger.info("\nOperation cancelled.")
+        sys.exit(0)
+
+    if response not in CONFIRM_RESPONSES:
+        logger.info("Operation cancelled.")
+        sys.exit(0)

uv.lock

@@ -339,16 +339,56 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
 ]
 
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
 [[package]]
 name = "skywipe"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
     { name = "atproto" },
+    { name = "pyyaml" },
 ]
 
 [package.metadata]
-requires-dist = [{ name = "atproto", specifier = ">=0.0.65" }]
+requires-dist = [
+    { name = "atproto", specifier = ">=0.0.65" },
+    { name = "pyyaml", specifier = ">=6.0" },
+]
 
 [[package]]
 name = "typing-extensions"