git-ew 0.1.0__py3-none-any.whl

git_ew/_internal/cli.py

@@ -0,0 +1,246 @@
+# SPDX-License-Identifier: ISC
+#
+# ISC License
+#
+# Copyright (c) 2026, Timothée Mazzucotelli and contributors
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+# Why does this file exist, and why not put this in `__main__`?
+#
+# You might be tempted to import things from `__main__` later,
+# but that will cause problems: the code will get executed twice:
+#
+# - When you run `python -m git_ew` python will execute
+#   `__main__.py` as a script. That means there won't be any
+#   `git_ew.__main__` in `sys.modules`.
+# - When you import `__main__` it will get executed again (as a module) because
+#   there's no `git_ew.__main__` in `sys.modules`.
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import sys
+from datetime import date
+from pathlib import Path
+from typing import Any
+from urllib.error import URLError
+
+import uvicorn
+
+from git_ew._internal import debug
+from git_ew._internal.config import config_command
+from git_ew._internal.database import Database
+from git_ew._internal.mailing_lists.zsh_workers.ingest import ingest_archives
+from git_ew._internal.mailing_lists.zsh_workers.sync_archives import (
+    _get_matching_archives,
+    download_archive,
+    fetch_archive_list,
+    get_missing_archives,
+)
+from git_ew._internal.sync import sync_command
+
+
+class _DebugInfo(argparse.Action):
+    def __init__(self, nargs: int | str | None = 0, **kwargs: Any) -> None:
+        super().__init__(nargs=nargs, **kwargs)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> None:  # noqa: ARG002
+        print(debug._format_debug_info())
+        sys.exit(0)
+
+
+def _parse_archive_date(value: str, *, end_of_year: bool = False) -> date:
+    """Parse a CLI archive date."""
+    try:
+        if len(value) == 4:  # noqa: PLR2004
+            year = int(value)
+            if end_of_year:
+                return date(year, 12, 31)
+            return date(year, 1, 1)
+        return date.fromisoformat(value)
+    except ValueError as error:
+        raise argparse.ArgumentTypeError(
+            f"invalid date {value!r}; use YYYY or YYYY-MM-DD",
+        ) from error
+
+
+def get_parser() -> argparse.ArgumentParser:
+    """Return the CLI argument parser.
+
+    Returns:
+        An argparse parser.
+    """
+    parser = argparse.ArgumentParser(
+        prog="git-ew",
+        description="Git Email Workflow - A web interface for email-based git workflows",
+    )
+    parser.add_argument("-V", "--version", action="version", version=f"%(prog)s {debug._get_version()}")
+    parser.add_argument("--debug-info", action=_DebugInfo, help="Print debug information.")
+
+    # Subcommands
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Server command
+    server_parser = subparsers.add_parser("serve", help="Start the web server")
+    server_parser.add_argument(
+        "--host",
+        default="127.0.0.1",
+        help="Host to bind to (default: 127.0.0.1)",
+    )
+    server_parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Port to bind to (default: 8000)",
+    )
+    server_parser.add_argument(
+        "--reload",
+        action="store_true",
+        help="Enable auto-reload for development",
+    )
+
+    # Init command
+    subparsers.add_parser("init", help="Initialize the database")
+
+    # Sync command
+    subparsers.add_parser("sync", help="Sync emails from configured sources")
+
+    # Configuration command
+    subparsers.add_parser("config", help="Configure email accounts and sources")
+
+    # Archive ingestion commands
+    ingest_parser = subparsers.add_parser("ingest", help="Ingest mailing-list archives")
+    ingest_subparsers = ingest_parser.add_subparsers(dest="ingest_source", required=True)
+    zsh_workers_parser = ingest_subparsers.add_parser(
+        "zsh-workers",
+        help="Download and ingest zsh-workers archives",
+    )
+    zsh_workers_parser.add_argument(
+        "--since",
+        type=_parse_archive_date,
+        help="Only include archives from this date (YYYY or YYYY-MM-DD)",
+    )
+    zsh_workers_parser.add_argument(
+        "--until",
+        type=lambda value: _parse_archive_date(value, end_of_year=True),
+        help="Only include archives through this date (YYYY or YYYY-MM-DD)",
+    )
+    zsh_workers_parser.add_argument(
+        "--archive-dir",
+        type=Path,
+        default=Path(".archives"),
+        help="Directory for archives (default: .archives)",
+    )
+    zsh_workers_parser.add_argument(
+        "--database",
+        default="sqlite:///./git_ew.db",
+        help="SQLAlchemy database URL (default: sqlite:///./git_ew.db)",
+    )
+    zsh_workers_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show archives to download without downloading or ingesting",
+    )
+    zsh_workers_parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="List archives selected for download",
+    )
+
+    return parser
+
+
+def main(args: list[str] | None = None) -> int:
+    """Run the main program.
+
+    This function is executed when you type `git-ew` or `python -m git_ew`.
+
+    Parameters:
+        args: Arguments passed from the command line.
+
+    Returns:
+        An exit code.
+    """
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    parser = get_parser()
+    opts = parser.parse_args(args=args)
+
+    if opts.command == "serve":
+        # Start the web server
+        print(f"Starting git-ew server at http://{opts.host}:{opts.port}")
+        print("Press Ctrl+C to stop the server")
+
+        uvicorn.run(
+            "git_ew._internal.app:app",
+            host=opts.host,
+            port=opts.port,
+            reload=opts.reload,
+        )
+        return 0
+
+    if opts.command == "init":
+        # Initialize the database
+        async def init_database() -> None:
+            db = Database()
+            await db.init_db()
+            print("Database initialized successfully")
+
+        asyncio.run(init_database())
+        return 0
+
+    if opts.command == "sync":
+        # Sync emails from sources
+        return asyncio.run(sync_command())
+
+    if opts.command == "config":
+        asyncio.run(config_command())
+        return 0
+
+    if opts.command == "ingest" and opts.ingest_source == "zsh-workers":
+        opts.archive_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            available = fetch_archive_list()
+        except URLError as error:
+            print(f"Error fetching zsh-workers archive list: {error}", file=sys.stderr)
+            return 1
+
+        matching = _get_matching_archives(available, opts.since, opts.until)
+        missing = get_missing_archives(opts.archive_dir, available, opts.since, opts.until)
+        print(f"Found {len(available)} archives available")
+        print(f"Found {len(matching)} matching archives")
+        print(f"Found {len(missing)} matching archives not downloaded")
+        if opts.verbose:
+            for filename in missing:
+                print(f"  - {filename}")
+        if opts.dry_run:
+            print("Dry-run: no archives downloaded or ingested")
+            return 0
+
+        failed = 0
+        for filename in missing:
+            if not download_archive(filename, opts.archive_dir):
+                failed += 1
+        if failed:
+            print(f"Error: {failed} archive download(s) failed", file=sys.stderr)
+            return 1
+
+        ingest_archives(opts.archive_dir, opts.database, filenames=matching)
+        return 0
+
+    # No command specified, show help
+    parser.print_help()
+    return 0

git_ew/_internal/config.py

@@ -0,0 +1,148 @@
+# SPDX-License-Identifier: ISC
+#
+# ISC License
+#
+# Copyright (c) 2026, Timothée Mazzucotelli and contributors
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+# Interactive git-ew configuration wizard.
+
+from __future__ import annotations
+
+import json
+import logging
+from asyncio import to_thread
+from getpass import getpass
+from typing import Any
+
+from git_ew._internal.database import Database
+from git_ew._internal.models import EmailSource
+
+_logger = logging.getLogger(__name__)
+
+
+def _prompt_password_config() -> dict[str, str]:
+    """Prompt for direct or command-based password storage."""
+    choice = input("Password storage: 1 direct, 2 command (default 1): ").strip() or "1"
+    if choice == "1":
+        return {"password": getpass("Password/App Password: ").strip()}
+    if choice == "2":
+        command = input("Password command: ").strip()
+        if not command:
+            raise ValueError("password command cannot be empty")
+        return {"password_command": command}
+    raise ValueError("password storage must be 1 or 2")
+
+
+def _prompt_email_config() -> dict[str, Any]:
+    """Collect email delivery settings from the terminal."""
+    _logger.info("Email Configuration (for sending replies)")
+    _logger.info("-" * 50)
+    smtp_host = input("SMTP Host (e.g., smtp.fastmail.com): ").strip()
+    smtp_port = input("SMTP Port (default 587): ").strip() or "587"
+    from_email = input("Your Email Address: ").strip()
+    from_name = input("Your Name: ").strip()
+    username = input("SMTP Username (default: same as email): ").strip() or from_email
+    use_tls = input("Use TLS? (Y/n): ").strip().lower() != "n"
+
+    email_config: dict[str, Any] = {
+        "smtp_host": smtp_host,
+        "smtp_port": int(smtp_port),
+        "from_email": from_email,
+        "from_name": from_name,
+        "username": username,
+        "use_tls": use_tls,
+        **_prompt_password_config(),
+    }
+    return email_config
+
+
+def _prompt_email_source() -> EmailSource | None:
+    """Collect an email source from the terminal."""
+    _logger.info("Email Source Configuration")
+    _logger.info("-" * 50)
+    _logger.info("Where should git-ew fetch emails from?")
+    _logger.info("1. Maildir (local maildir folder)")
+    _logger.info("2. Mbox (mbox archive file)")
+    _logger.info("3. IMAP (Fastmail or another IMAP server)")
+    _logger.info("4. Skip for now")
+
+    choice = input("\nChoice (1-4): ").strip()
+    if choice == "1":
+        source = EmailSource(
+            name=input("Source name (e.g., 'my-maildir'): ").strip(),
+            source_type="maildir",
+            config=json.dumps({"path": input("Path to maildir folder: ").strip()}),
+            enabled=True,
+        )
+    elif choice == "2":
+        source = EmailSource(
+            name=input("Source name (e.g., 'mailing-list'): ").strip(),
+            source_type="mbox",
+            config=json.dumps({"path": input("Path to mbox file: ").strip()}),
+            enabled=True,
+        )
+    elif choice == "3":
+        folders = input("Folders (comma-separated, default: INBOX,Sent): ").strip() or "INBOX,Sent"
+        addresses = input("Mailing-list addresses (default: zsh-workers@zsh.org): ").strip() or "zsh-workers@zsh.org"
+        list_ids = (
+            input("Mailing-list List-Id values (default: zsh-workers.zsh.org): ").strip() or "zsh-workers.zsh.org"
+        )
+        source = EmailSource(
+            name=input("Source name (e.g., 'fastmail'): ").strip(),
+            source_type="imap",
+            config=json.dumps(
+                {
+                    "host": input("IMAP Host (default: imap.fastmail.com): ").strip() or "imap.fastmail.com",
+                    "port": int(input("IMAP Port (default: 993): ").strip() or "993"),
+                    "username": input("IMAP Username (your Fastmail address): ").strip(),
+                    "folders": [folder.strip() for folder in folders.split(",") if folder.strip()],
+                    "mailing_list": {
+                        "addresses": [address.strip().lower() for address in addresses.split(",") if address.strip()],
+                        "list_ids": [list_id.strip().lower() for list_id in list_ids.split(",") if list_id.strip()],
+                    },
+                    **_prompt_password_config(),
+                },
+            ),
+            enabled=True,
+        )
+    else:
+        _logger.info("Skipped email source configuration")
+        return None
+
+    return source
+
+
+async def config_command() -> None:
+    """Configure email delivery and ingestion sources interactively."""
+    _logger.info("=== git-ew Configuration Wizard ===")
+
+    db = Database()
+    _logger.info("Initializing database")
+    await db.init_db()
+    _logger.info("Database initialized")
+
+    email_config = await to_thread(_prompt_email_config)
+    await db.set_config("email_config", email_config)
+    _logger.info("Email configuration saved")
+
+    source = await to_thread(_prompt_email_source)
+    if source is None:
+        return
+
+    async with db.session() as session:
+        session.add(source)
+    _logger.info("Email source added")
+    _logger.info("=" * 50)
+    _logger.info("Configuration complete")

git_ew/_internal/database.py

@@ -0,0 +1,297 @@
+# SPDX-License-Identifier: ISC
+#
+# ISC License
+#
+# Copyright (c) 2026, Timothée Mazzucotelli and contributors
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+# Database operations for git-ew.
+
+from __future__ import annotations
+
+import json
+from contextlib import asynccontextmanager
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import selectinload
+
+from git_ew._internal.models import Base, Configuration, EmailSource, Message, Thread
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+
+class Database:
+    """Database manager."""
+
+    def __init__(self, database_url: str = "sqlite+aiosqlite:///./git_ew.db"):
+        """Initialize database manager.
+
+        Args:
+            database_url: Database connection URL.
+        """
+        self.engine = create_async_engine(database_url, echo=False)
+        """SQLAlchemy async engine instance."""
+        self.session_maker = async_sessionmaker(self.engine, class_=AsyncSession, expire_on_commit=False)
+        """Async session factory."""
+
+    async def init_db(self) -> None:
+        """Initialize database tables."""
+        async with self.engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+
+    @asynccontextmanager
+    async def session(self) -> AsyncIterator[AsyncSession]:
+        """Get a database session."""
+        async with self.session_maker() as session:
+            try:
+                yield session
+                await session.commit()
+            except Exception:
+                await session.rollback()
+                raise
+
+    async def get_threads(
+        self,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list[Thread]:
+        """Get threads with optional filtering.
+
+        Args:
+            status: Filter by status (open/closed).
+            limit: Maximum number of threads to return.
+            offset: Number of threads to skip.
+
+        Returns:
+            List of threads.
+        """
+        async with self.session() as session:
+            query = select(Thread).order_by(Thread.updated_at.desc())
+            if status:
+                query = query.where(Thread.status == status)
+            if limit is not None:
+                query = query.limit(limit)
+            query = query.offset(offset)
+            result = await session.execute(query)
+            return list(result.scalars().all())
+
+    async def get_thread(self, thread_id: int) -> Thread | None:
+        """Get a thread by ID with all messages.
+
+        Args:
+            thread_id: Thread ID.
+
+        Returns:
+            Thread or None if not found.
+        """
+        async with self.session() as session:
+            query = select(Thread).where(Thread.id == thread_id).options(selectinload(Thread.messages))
+            result = await session.execute(query)
+            return result.scalar_one_or_none()
+
+    async def get_thread_by_message_id(self, message_id: str) -> Thread | None:
+        """Get a thread by first message ID.
+
+        Args:
+            message_id: Message ID.
+
+        Returns:
+            Thread or None if not found.
+        """
+        async with self.session() as session:
+            query = select(Thread).where(Thread.first_message_id == message_id)
+            result = await session.execute(query)
+            return result.scalar_one_or_none()
+
+    async def create_thread(
+        self,
+        subject: str,
+        first_message_id: str,
+        *,
+        is_patch: bool = False,
+    ) -> Thread:
+        """Create a new thread.
+
+        Args:
+            subject: Thread subject.
+            first_message_id: ID of the first message.
+            is_patch: Whether this thread contains patches.
+
+        Returns:
+            Created thread.
+        """
+        now = datetime.now(UTC)
+        thread = Thread(
+            subject=subject,
+            first_message_id=first_message_id,
+            created_at=now,
+            updated_at=now,
+            is_patch=is_patch,
+            status="open",
+        )
+        async with self.session() as session:
+            session.add(thread)
+            await session.flush()
+            await session.refresh(thread)
+            return thread
+
+    async def create_message(  # noqa: PLR0917
+        self,
+        message_id: str,
+        thread_id: int,
+        from_email: str,
+        from_name: str,
+        subject: str,
+        date: datetime,
+        body: str,
+        *,
+        in_reply_to: str | None = None,
+        is_patch: bool = False,
+        patch_content: str | None = None,
+        raw_email: str | None = None,
+    ) -> Message:
+        """Create a new message.
+
+        Args:
+            message_id: Unique message ID.
+            thread_id: Thread ID this message belongs to.
+            from_email: Sender email.
+            from_name: Sender name.
+            subject: Message subject.
+            date: Message date.
+            body: Message body.
+            in_reply_to: ID of message this replies to.
+            is_patch: Whether this message contains a patch.
+            patch_content: Patch content if applicable.
+            raw_email: Raw email content.
+
+        Returns:
+            Created message.
+        """
+        message = Message(
+            message_id=message_id,
+            thread_id=thread_id,
+            from_email=from_email,
+            from_name=from_name,
+            subject=subject,
+            date=date,
+            body=body,
+            in_reply_to=in_reply_to,
+            is_patch=is_patch,
+            patch_content=patch_content,
+            raw_email=raw_email,
+        )
+        async with self.session() as session:
+            session.add(message)
+
+            # Update thread's updated_at
+            thread = await session.get(Thread, thread_id)
+            if thread:
+                thread.updated_at = datetime.now(UTC)
+
+            await session.flush()
+            await session.refresh(message)
+            return message
+
+    async def get_message_by_id(self, message_id: str) -> Message | None:
+        """Get a message by its message ID.
+
+        Args:
+            message_id: Message ID.
+
+        Returns:
+            Message or None if not found.
+        """
+        async with self.session() as session:
+            query = select(Message).where(Message.message_id == message_id)
+            result = await session.execute(query)
+            return result.scalar_one_or_none()
+
+    async def update_message_patch(self, message_id: str, patch_content: str) -> None:
+        """Add patch content to an existing message."""
+        async with self.session() as session:
+            query = select(Message).where(Message.message_id == message_id)
+            result = await session.execute(query)
+            message = result.scalar_one_or_none()
+            if message and not message.patch_content:
+                message.patch_content = patch_content
+                message.is_patch = True
+                thread = await session.get(Thread, message.thread_id)
+                if thread:
+                    thread.is_patch = True
+
+    async def get_config(self, key: str, default: Any = None) -> Any:
+        """Get a configuration value.
+
+        Args:
+            key: Configuration key.
+            default: Default value if key not found.
+
+        Returns:
+            Configuration value or default.
+        """
+        async with self.session() as session:
+            query = select(Configuration).where(Configuration.key == key)
+            result = await session.execute(query)
+            config = result.scalar_one_or_none()
+            if config:
+                return json.loads(config.value)
+            return default
+
+    async def set_config(self, key: str, value: Any) -> None:
+        """Set a configuration value.
+
+        Args:
+            key: Configuration key.
+            value: Configuration value.
+        """
+        async with self.session() as session:
+            query = select(Configuration).where(Configuration.key == key)
+            result = await session.execute(query)
+            config = result.scalar_one_or_none()
+
+            if config:
+                config.value = json.dumps(value)
+            else:
+                config = Configuration(key=key, value=json.dumps(value))
+                session.add(config)
+
+    async def get_email_sources(self) -> list[EmailSource]:
+        """Get all email sources.
+
+        Returns:
+            List of email sources.
+        """
+        async with self.session() as session:
+            query = select(EmailSource)
+            result = await session.execute(query)
+            return list(result.scalars().all())
+
+    async def update_thread_status(self, thread_id: int, status: str) -> None:
+        """Update thread status.
+
+        Args:
+            thread_id: Thread ID.
+            status: New status (open/closed).
+        """
+        async with self.session() as session:
+            thread = await session.get(Thread, thread_id)
+            if thread:
+                thread.status = status
+                thread.updated_at = datetime.now(UTC)