minigist 0.1.2__tar.gz

minigist-0.1.2/.python-version

@@ -0,0 +1 @@
+3.13

minigist-0.1.2/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 eikendev
+
+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.

minigist-0.1.2/MANIFEST.in

@@ -0,0 +1,4 @@
+exclude .gitignore
+exclude uv.lock
+recursive-exclude .clinerules *
+recursive-exclude .github *

minigist-0.1.2/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: minigist
+Version: 0.1.2
+Summary: A tool that generates concise summaries for you Miniflux feeds.
+Author: eikendev
+Maintainer: eikendev
+Project-URL: Homepage, https://github.com/eikendev/minigist
+Keywords: miniflux,rss,feed,ai,summarization,cli
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content :: News/Diary
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Utilities
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: apprise>=1.9.3
+Requires-Dist: click>=8.1.8
+Requires-Dist: lxml[html-clean]>=5.4.0
+Requires-Dist: markdown>=3.8
+Requires-Dist: miniflux>=1.1.3
+Requires-Dist: newspaper3k>=0.2.8
+Requires-Dist: pydantic-ai>=0.1.6
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: structlog>=25.3.0
+Dynamic: license-file
+
+<div align="center">
+	<h1>minigist</h1>
+	<h4 align="center">
+		AI-powered summaries for your <a href="https://miniflux.app/">Miniflux</a> feeds.
+	</h4>
+	<p>Turn your long Miniflux articles into clear, concise summaries.</p>
+</div>
+
+<p align="center">
+	<a href="https://github.com/eikendev/minigist/actions"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/eikendev/minigist/main.yml?branch=main"/></a>&nbsp;
+	<a href="https://github.com/eikendev/minigist/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/github/license/eikendev/minigist"/></a>&nbsp;
+	<a href="https://pypi.org/project/minigist/"><img alt="PyPI" src="https://img.shields.io/pypi/v/minigist"/></a>&nbsp;
+</p>
+
+## 🤘&nbsp;Features
+
+- **Automatic summarization** of unread Miniflux entries
+- **Configurable filters** to target specific feeds
+- **Notification support** via Apprise for various messaging services
+- **Dry-run mode** to preview changes without modifying entries
+- **Structured logging** for better debugging and monitoring
+
+## 🚀&nbsp;Installation
+
+Install minigist using `pip`:
+
+```bash
+pip install minigist
+```
+
+Install minigist using `uv`:
+
+```bash
+uv tool install minigist
+```
+
+## 📄&nbsp;Usage
+
+### Configuration
+
+Create a configuration file at `~/.config/minigist/config.yaml`:
+
+```yaml
+miniflux:
+  url: "https://your-miniflux-instance.com"
+  api_key: "your-miniflux-api-key"
+
+ai:
+  api_key: "your-ai-service-api-key"
+  base_url: "https://openrouter.ai/api/v1"  # Default
+  model: "google/gemini-2.5-flash-preview"  # Default
+  system_prompt: "Generate an executive summary of the provided article."  # Default
+
+filters:
+  feed_ids: [1, 2, 3]  # Optional
+  fetch_limit: 100     # Default
+
+notifications:
+  urls:                # Apprise notification URLs (optional)
+    - "discord://webhook_id/webhook_token"
+    - "telegram://bot_token/chat_id"
+```
+
+See [Apprise documentation](https://github.com/caronc/apprise) for all supported notification services.
+
+### Basic Commands
+
+Run minigist to process unread entries:
+
+```bash
+minigist run
+```
+
+Run in dry-run mode to see what would happen without making changes:
+
+```bash
+minigist run --dry-run
+```
+
+Increase logging verbosity:
+
+```bash
+minigist run --log-level DEBUG
+```
+
+Use a different configuration file:
+
+```bash
+minigist run --config-file /path/to/config.yaml
+```

minigist-0.1.2/README.md

@@ -0,0 +1,90 @@
+<div align="center">
+	<h1>minigist</h1>
+	<h4 align="center">
+		AI-powered summaries for your <a href="https://miniflux.app/">Miniflux</a> feeds.
+	</h4>
+	<p>Turn your long Miniflux articles into clear, concise summaries.</p>
+</div>
+
+<p align="center">
+	<a href="https://github.com/eikendev/minigist/actions"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/eikendev/minigist/main.yml?branch=main"/></a>&nbsp;
+	<a href="https://github.com/eikendev/minigist/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/github/license/eikendev/minigist"/></a>&nbsp;
+	<a href="https://pypi.org/project/minigist/"><img alt="PyPI" src="https://img.shields.io/pypi/v/minigist"/></a>&nbsp;
+</p>
+
+## 🤘&nbsp;Features
+
+- **Automatic summarization** of unread Miniflux entries
+- **Configurable filters** to target specific feeds
+- **Notification support** via Apprise for various messaging services
+- **Dry-run mode** to preview changes without modifying entries
+- **Structured logging** for better debugging and monitoring
+
+## 🚀&nbsp;Installation
+
+Install minigist using `pip`:
+
+```bash
+pip install minigist
+```
+
+Install minigist using `uv`:
+
+```bash
+uv tool install minigist
+```
+
+## 📄&nbsp;Usage
+
+### Configuration
+
+Create a configuration file at `~/.config/minigist/config.yaml`:
+
+```yaml
+miniflux:
+  url: "https://your-miniflux-instance.com"
+  api_key: "your-miniflux-api-key"
+
+ai:
+  api_key: "your-ai-service-api-key"
+  base_url: "https://openrouter.ai/api/v1"  # Default
+  model: "google/gemini-2.5-flash-preview"  # Default
+  system_prompt: "Generate an executive summary of the provided article."  # Default
+
+filters:
+  feed_ids: [1, 2, 3]  # Optional
+  fetch_limit: 100     # Default
+
+notifications:
+  urls:                # Apprise notification URLs (optional)
+    - "discord://webhook_id/webhook_token"
+    - "telegram://bot_token/chat_id"
+```
+
+See [Apprise documentation](https://github.com/caronc/apprise) for all supported notification services.
+
+### Basic Commands
+
+Run minigist to process unread entries:
+
+```bash
+minigist run
+```
+
+Run in dry-run mode to see what would happen without making changes:
+
+```bash
+minigist run --dry-run
+```
+
+Increase logging verbosity:
+
+```bash
+minigist run --log-level DEBUG
+```
+
+Use a different configuration file:
+
+```bash
+minigist run --config-file /path/to/config.yaml
+```

minigist-0.1.2/minigist/cli.py

@@ -0,0 +1,73 @@
+import sys
+from typing import Optional
+
+import click
+
+from minigist import config, exceptions, notification
+from minigist.logging import configure_logging, get_logger
+from minigist.processor import Processor
+
+MINIGIST_ENV_PREFIX = "MINIGIST"
+
+logger = get_logger(__name__)
+
+
+@click.group(context_settings=dict(auto_envvar_prefix=MINIGIST_ENV_PREFIX))
+def cli():
+    """
+    A tool that generates concise summaries for you Miniflux feeds.
+    """
+    pass
+
+
+@cli.command()
+@click.option(
+    "--config-file",
+    type=click.Path(dir_okay=False),
+    help="Path to the YAML configuration file.",
+)
+@click.option(
+    "--log-level",
+    type=click.Choice(
+        ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"], case_sensitive=False
+    ),
+    default="INFO",
+    show_default=True,
+    help="Set the logging level.",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    default=False,
+    help="Perform a dry run without updating Miniflux.",
+)
+def run(
+    config_file: Optional[str],
+    log_level: str,
+    dry_run: bool,
+):
+    """Fetch entries, summarize, and update Miniflux."""
+    configure_logging(log_level)
+
+    try:
+        app_config = config.load_app_config(config_file)
+    except exceptions.ConfigError as e:
+        logger.critical("Configuration error", error=str(e))
+        sys.exit(1)
+
+    notifier = notification.AppriseNotifier(app_config.notifications.urls)
+
+    try:
+        processor = Processor(app_config, dry_run=dry_run)
+        processor.run()
+    except Exception as e:
+        logger.critical("An error occurred during processing", error=str(e))
+        notifier.notify(
+            title="Minigist Critical Error",
+            body=f"An error occurred during processing: {e}",
+        )
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli()

minigist-0.1.2/minigist/config.py

@@ -0,0 +1,122 @@
+from pathlib import Path
+from typing import List, Optional
+
+import yaml
+from pydantic import BaseModel, Field, HttpUrl, ValidationError
+
+from minigist.exceptions import ConfigError
+from minigist.logging import get_logger
+
+logger = get_logger(__name__)
+
+DEFAULT_CONFIG_PATHS = [
+    Path("~/.config/minigist/config.yaml").expanduser(),
+    Path("~/.config/minigist/config.yml").expanduser(),
+    Path("./config.yaml"),
+    Path("./config.yml"),
+    Path("/etc/minigist/config.yaml"),
+    Path("/etc/minigist/config.yml"),
+]
+
+
+class MinifluxConfig(BaseModel):
+    url: HttpUrl = Field(..., description="URL of the Miniflux instance.")
+    api_key: str = Field(..., description="Miniflux API key.")
+
+
+class AIServiceConfig(BaseModel):
+    model: str = Field(
+        "google/gemini-2.5-flash-preview",
+        description="AI model identifier to use for summarization.",
+    )
+    system_prompt: str = Field(
+        "Generate an executive summary of the provided article.",
+        description="System prompt to guide the AI summarization.",
+    )
+    api_key: str = Field(
+        ...,
+        description="API key for the AI service.",
+    )
+    base_url: Optional[str] = Field(
+        "https://openrouter.ai/api/v1",
+        description="Base URL for the AI service API.",
+    )
+
+
+class NotificationConfig(BaseModel):
+    urls: List[str] = Field(
+        default_factory=list, description="List of Apprise notification URLs."
+    )
+
+
+class FilterConfig(BaseModel):
+    feed_ids: Optional[List[int]] = Field(
+        None, description="List of specific feed IDs to include (fetch all if None)."
+    )
+    fetch_limit: Optional[int] = Field(
+        100, description="Maximum number of entries to fetch."
+    )
+    fetch_days: Optional[int] = Field(
+        None,
+        description="Number of past days to fetch entries from.",
+    )
+
+
+class AppConfig(BaseModel):
+    miniflux: MinifluxConfig
+    ai: AIServiceConfig
+    notifications: NotificationConfig = Field(
+        default_factory=lambda: NotificationConfig.model_construct()
+    )
+    filters: FilterConfig = Field(
+        default_factory=lambda: FilterConfig.model_construct()
+    )
+
+
+def find_config_file(config_option: Optional[str] = None) -> Path:
+    search_paths = (
+        [Path(config_option)] if config_option else []
+    ) + DEFAULT_CONFIG_PATHS
+
+    for path in search_paths:
+        logger.debug("Checking path for config file", path=str(path))
+        if path.is_file():
+            logger.debug("Found config file", path=str(path))
+            return path
+
+    raise ConfigError("No valid config file found")
+
+
+def load_config_from_file(file_path: Path) -> dict:
+    try:
+        with open(file_path, "r") as f:
+            config_data = yaml.safe_load(f)
+    except FileNotFoundError as e:
+        logger.error("Config file not found", path=str(file_path))
+        raise ConfigError("Config file not found") from e
+    except yaml.YAMLError as e:
+        logger.error("Error parsing YAML file", path=str(file_path), error=str(e))
+        raise ConfigError("Error parsing YAML file") from e
+    except Exception as e:
+        logger.error("Error reading config file", path=str(file_path), error=str(e))
+        raise ConfigError("Error reading config file") from e
+
+    if config_data is None:
+        logger.warning("Config file is empty", path=str(file_path))
+        raise ConfigError("Config file is empty")
+
+    logger.debug("Loaded configuration", path=str(file_path))
+    return config_data
+
+
+def load_app_config(config_path_option: Optional[str] = None) -> AppConfig:
+    config_file = find_config_file(config_path_option)
+    config_data = load_config_from_file(config_file)
+
+    try:
+        app_config = AppConfig(**config_data)
+    except ValidationError as e:
+        logger.error("Error validating application configuration", error=str(e))
+        raise ConfigError("Invalid or incomplete configuration") from e
+
+    return app_config

minigist-0.1.2/minigist/constants.py

@@ -0,0 +1,2 @@
+WATERMARK = "*Summarized by minigist* ([GitHub](https://github.com/eikendev/minigist))"
+WATERMARK_DETECTOR = "Summarized by minigist"

minigist-0.1.2/minigist/exceptions.py

@@ -0,0 +1,22 @@
+class MinigistError(Exception):
+    pass
+
+
+class ConfigError(MinigistError):
+    pass
+
+
+class MinifluxApiError(MinigistError):
+    pass
+
+
+class SummarizationError(MinigistError):
+    pass
+
+
+class ArticleFetchError(SummarizationError):
+    pass
+
+
+class AIServiceError(SummarizationError):
+    pass

minigist-0.1.2/minigist/logging.py

@@ -0,0 +1,46 @@
+import logging
+import sys
+
+import structlog
+
+
+def configure_logging(log_level_str: str = "INFO") -> None:
+    """
+    Configure structlog for the application.
+    """
+    log_level = getattr(logging, log_level_str.upper(), logging.INFO)
+
+    logging.basicConfig(
+        format="%(message)s",
+        stream=sys.stderr,
+        level=log_level,
+    )
+
+    for logger_name in logging.root.manager.loggerDict:
+        if not logger_name.startswith("minigist"):
+            logging.getLogger(logger_name).setLevel(logging.WARNING)
+
+    structlog.configure(
+        processors=[
+            structlog.stdlib.filter_by_level,
+            structlog.stdlib.add_logger_name,
+            structlog.stdlib.add_log_level,
+            structlog.stdlib.PositionalArgumentsFormatter(),
+            structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S"),
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.format_exc_info,
+            structlog.processors.UnicodeDecoder(),
+            structlog.dev.ConsoleRenderer(),
+        ],
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+
+
+def get_logger(name: str) -> structlog.stdlib.BoundLogger:
+    """
+    Get a structured logger with the given name.
+    """
+    return structlog.get_logger(name)

minigist-0.1.2/minigist/miniflux_client.py

@@ -0,0 +1,60 @@
+from typing import List
+
+from miniflux import Client  # type: ignore
+
+from .config import FilterConfig, MinifluxConfig
+from .exceptions import MinifluxApiError
+from .logging import get_logger
+from .models import EntriesResponse, Entry
+
+logger = get_logger(__name__)
+
+
+class MinifluxClient:
+    def __init__(self, config: MinifluxConfig, dry_run: bool = False):
+        self.client = Client(base_url=str(config.url), api_key=config.api_key)
+        self.dry_run = dry_run
+
+        if dry_run:
+            logger.warning("Running in dry run mode; no updates will be made")
+
+    def get_entries(self, filters: FilterConfig) -> List[Entry]:
+        params = {
+            "status": "unread",
+            "direction": "desc",
+            "limit": 1,
+        }
+
+        logger.debug("Fetching entries", parameters=params)
+
+        try:
+            raw_response = self.client.get_entries(**params)
+        except Exception as e:
+            logger.error("Failed to fetch entries from Miniflux", error=str(e))
+            raise MinifluxApiError("Failed to fetch entries") from e
+
+        try:
+            response = EntriesResponse.model_validate(raw_response)
+        except Exception as e:
+            logger.error("Failed to parse entries response", error=str(e))
+            raise MinifluxApiError("Failed to parse entries response") from e
+
+        entries = response.entries
+        logger.info("Fetched unread entries", count=len(entries))
+
+        return entries
+
+    def update_entry(self, entry_id: int, content: str):
+        logger.debug("Updating entry", entry_id=entry_id, content=content)
+
+        if self.dry_run:
+            logger.debug(
+                "Would update entry; skipping due to dry run", entry_id=entry_id
+            )
+            return
+
+        try:
+            self.client.update_entry(entry_id=entry_id, content=content)
+        except Exception as e:
+            logger.error("Failed to update entry", entry_id=entry_id, error=str(e))
+            raise MinifluxApiError(f"Failed to update entry ID {entry_id}") from e

minigist-0.1.2/minigist/models.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+from typing import List
+
+from pydantic import BaseModel
+
+
+class Entry(BaseModel):
+    id: int
+    user_id: int
+    feed_id: int
+    title: str
+    url: str
+    comments_url: str = ""
+    author: str = ""
+    content: str = ""
+    hash: str
+    published_at: datetime
+    created_at: datetime
+    status: str
+    share_code: str = ""
+    starred: bool = False
+    reading_time: int = 0
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class EntriesResponse(BaseModel):
+    total: int
+    entries: List[Entry]

minigist-0.1.2/minigist/notification.py

@@ -0,0 +1,41 @@
+from typing import List
+
+import apprise
+
+from .logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class AppriseNotifier:
+    def __init__(self, urls: List[str]):
+        self.apobj = apprise.Apprise()
+        self.has_urls = False
+
+        if urls:
+            for url in urls:
+                if self.apobj.add(url):
+                    logger.info("Added Apprise notification URL", url=url)
+                    self.has_urls = True
+                else:
+                    logger.error("Failed to add invalid Apprise URL", url=url)
+        else:
+            logger.warning("No Apprise notification URLs configured")
+
+    def notify(self, title: str, body: str) -> None:
+        if not self.has_urls:
+            logger.debug("Skipping notification: No valid Apprise URLs configured")
+            return
+
+        try:
+            logger.info("Sending notification", title=title)
+            sent = self.apobj.notify(body=body, title=title)
+            if sent:
+                logger.debug("Notification sent successfully")
+            else:
+                logger.error(
+                    "Failed to send notification to any configured Apprise URL"
+                )
+
+        except Exception as e:
+            logger.error("Error sending notification via Apprise", error=str(e))

minigist-0.1.2/minigist/processor.py

@@ -0,0 +1,74 @@
+from typing import List
+
+import markdown
+
+from .config import AppConfig
+from .constants import WATERMARK, WATERMARK_DETECTOR
+from .logging import get_logger
+from .miniflux_client import MinifluxClient
+from .models import Entry
+from .summarizer import Summarizer
+
+logger = get_logger(__name__)
+
+
+class Processor:
+    def __init__(self, config: AppConfig, dry_run: bool = False):
+        self.config = config
+        self.client = MinifluxClient(config.miniflux, dry_run=dry_run)
+        self.summarizer = Summarizer(config.ai)
+        logger.debug("Processor initialized", dry_run=dry_run)
+
+    def _filter_unsummarized_entries(self, entries: List[Entry]) -> List[Entry]:
+        unsummarized = [
+            entry for entry in entries if WATERMARK_DETECTOR not in entry.content
+        ]
+        logger.debug(
+            "Filtered entries",
+            total=len(entries),
+            unsummarized=len(unsummarized),
+            filtered=len(entries) - len(unsummarized),
+        )
+        return unsummarized
+
+    def _process_single_entry(self, entry: Entry) -> bool:
+        logger.debug("Processing entry", entry_id=entry.id, title=entry.title)
+
+        article_text = self.summarizer.fetch_and_parse_article(entry.url)
+        if not article_text:
+            logger.warning(
+                "No article text extracted", entry_id=entry.id, url=entry.url
+            )
+            return True
+
+        summary = self.summarizer.generate_summary(article_text)
+
+        markdown_content = f"{summary}\n\n---\n\n{WATERMARK}"
+        new_content = markdown.markdown(markdown_content)
+
+        self.client.update_entry(entry_id=entry.id, content=new_content)
+        return True
+
+    def run(self) -> None:
+        logger.debug("Starting minigist processor")
+
+        entries = self.client.get_entries(self.config.filters)
+
+        if not entries:
+            logger.info("No matching unread entries found")
+            return
+
+        logger.debug("Fetched entries", count=len(entries))
+
+        entries = self._filter_unsummarized_entries(entries)
+
+        if not entries:
+            logger.info("All entries have already been summarized")
+            return
+
+        logger.info("Processing entries", count=len(entries))
+
+        for entry in entries:
+            self._process_single_entry(entry)
+
+        logger.info("Successfully processed entries", count=len(entries))

minigist-0.1.2/minigist/summarizer.py

@@ -0,0 +1,78 @@
+from typing import Optional
+
+from newspaper import Article, ArticleException  # type: ignore
+from pydantic_ai import Agent
+from pydantic_ai.models.openai import OpenAIModel
+from pydantic_ai.providers.openai import OpenAIProvider
+
+from .config import AIServiceConfig
+from .exceptions import AIServiceError, ArticleFetchError
+from .logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class Summarizer:
+    def __init__(self, config: AIServiceConfig):
+        logger.debug(
+            "Using custom API configuration",
+            has_api_key=bool(config.api_key),
+            has_base_url=bool(config.base_url),
+        )
+
+        model = OpenAIModel(
+            config.model,
+            provider=OpenAIProvider(
+                base_url=config.base_url,
+                api_key=config.api_key,
+            ),
+        )
+        self.agent = Agent(
+            model,
+            system_prompt=config.system_prompt,
+        )
+
+    def fetch_and_parse_article(self, url: str) -> Optional[str]:
+        logger.debug("Fetching article content", url=url)
+
+        try:
+            article = Article(url)
+            article.download()
+            article.parse()
+        except ArticleException as e:
+            logger.error("Newspaper3k failed to process article", url=url, error=str(e))
+            raise ArticleFetchError(f"Failed to fetch/parse article {url}") from e
+        except Exception as e:
+            logger.error(
+                "Unexpected error fetching article",
+                url=url,
+                error=str(e),
+            )
+            raise ArticleFetchError(f"Unexpected error fetching article {url}") from e
+
+        text = article.text
+
+        if not text:
+            logger.warning("No text content extracted from article", url=url)
+            return None
+
+        logger.debug("Successfully extracted text", url=url, length=len(text))
+        return text
+
+    def generate_summary(self, article_text: str) -> str:
+        logger.debug("Generating article summary", length=len(article_text))
+
+        try:
+            result = self.agent.run_sync(article_text)
+        except Exception as e:
+            logger.error("Unexpected error during summarization", error=str(e))
+            raise AIServiceError("Unexpected error during summarization") from e
+
+        if not result or not result.output:
+            logger.error("AI service returned an empty result")
+            raise AIServiceError("AI service returned an empty result")
+
+        summary = result.output
+        logger.debug("Successfully generated summary", length=len(summary))
+
+        return summary

minigist-0.1.2/minigist.egg-info/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: minigist
+Version: 0.1.2
+Summary: A tool that generates concise summaries for you Miniflux feeds.
+Author: eikendev
+Maintainer: eikendev
+Project-URL: Homepage, https://github.com/eikendev/minigist
+Keywords: miniflux,rss,feed,ai,summarization,cli
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content :: News/Diary
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Utilities
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: apprise>=1.9.3
+Requires-Dist: click>=8.1.8
+Requires-Dist: lxml[html-clean]>=5.4.0
+Requires-Dist: markdown>=3.8
+Requires-Dist: miniflux>=1.1.3
+Requires-Dist: newspaper3k>=0.2.8
+Requires-Dist: pydantic-ai>=0.1.6
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: structlog>=25.3.0
+Dynamic: license-file
+
+<div align="center">
+	<h1>minigist</h1>
+	<h4 align="center">
+		AI-powered summaries for your <a href="https://miniflux.app/">Miniflux</a> feeds.
+	</h4>
+	<p>Turn your long Miniflux articles into clear, concise summaries.</p>
+</div>
+
+<p align="center">
+	<a href="https://github.com/eikendev/minigist/actions"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/eikendev/minigist/main.yml?branch=main"/></a>&nbsp;
+	<a href="https://github.com/eikendev/minigist/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/github/license/eikendev/minigist"/></a>&nbsp;
+	<a href="https://pypi.org/project/minigist/"><img alt="PyPI" src="https://img.shields.io/pypi/v/minigist"/></a>&nbsp;
+</p>
+
+## 🤘&nbsp;Features
+
+- **Automatic summarization** of unread Miniflux entries
+- **Configurable filters** to target specific feeds
+- **Notification support** via Apprise for various messaging services
+- **Dry-run mode** to preview changes without modifying entries
+- **Structured logging** for better debugging and monitoring
+
+## 🚀&nbsp;Installation
+
+Install minigist using `pip`:
+
+```bash
+pip install minigist
+```
+
+Install minigist using `uv`:
+
+```bash
+uv tool install minigist
+```
+
+## 📄&nbsp;Usage
+
+### Configuration
+
+Create a configuration file at `~/.config/minigist/config.yaml`:
+
+```yaml
+miniflux:
+  url: "https://your-miniflux-instance.com"
+  api_key: "your-miniflux-api-key"
+
+ai:
+  api_key: "your-ai-service-api-key"
+  base_url: "https://openrouter.ai/api/v1"  # Default
+  model: "google/gemini-2.5-flash-preview"  # Default
+  system_prompt: "Generate an executive summary of the provided article."  # Default
+
+filters:
+  feed_ids: [1, 2, 3]  # Optional
+  fetch_limit: 100     # Default
+
+notifications:
+  urls:                # Apprise notification URLs (optional)
+    - "discord://webhook_id/webhook_token"
+    - "telegram://bot_token/chat_id"
+```
+
+See [Apprise documentation](https://github.com/caronc/apprise) for all supported notification services.
+
+### Basic Commands
+
+Run minigist to process unread entries:
+
+```bash
+minigist run
+```
+
+Run in dry-run mode to see what would happen without making changes:
+
+```bash
+minigist run --dry-run
+```
+
+Increase logging verbosity:
+
+```bash
+minigist run --log-level DEBUG
+```
+
+Use a different configuration file:
+
+```bash
+minigist run --config-file /path/to/config.yaml
+```

minigist-0.1.2/minigist.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+.python-version
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+minigist/__init__.py
+minigist/cli.py
+minigist/config.py
+minigist/constants.py
+minigist/exceptions.py
+minigist/logging.py
+minigist/miniflux_client.py
+minigist/models.py
+minigist/notification.py
+minigist/processor.py
+minigist/summarizer.py
+minigist.egg-info/PKG-INFO
+minigist.egg-info/SOURCES.txt
+minigist.egg-info/dependency_links.txt
+minigist.egg-info/entry_points.txt
+minigist.egg-info/requires.txt
+minigist.egg-info/top_level.txt
+tests/__init__.py
+tests/conftest.py
+tests/unit/__init__.py
+tests/unit/test_config.py

minigist-0.1.2/minigist.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

minigist-0.1.2/minigist.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+minigist = minigist.cli:cli

minigist-0.1.2/minigist.egg-info/requires.txt

@@ -0,0 +1,9 @@
+apprise>=1.9.3
+click>=8.1.8
+lxml[html-clean]>=5.4.0
+markdown>=3.8
+miniflux>=1.1.3
+newspaper3k>=0.2.8
+pydantic-ai>=0.1.6
+pyyaml>=6.0.2
+structlog>=25.3.0

minigist-0.1.2/minigist.egg-info/top_level.txt

@@ -0,0 +1 @@
+minigist

minigist-0.1.2/pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "minigist"
+description = "A tool that generates concise summaries for you Miniflux feeds."
+readme = "README.md"
+license-files = ["LICENSE"]
+requires-python = ">=3.13"
+dynamic = ["version"]
+authors = [
+    {name = "eikendev"},
+]
+maintainers = [
+    {name = "eikendev"},
+]
+keywords = ["miniflux", "rss", "feed", "ai", "summarization", "cli"]
+classifiers = [
+    "Environment :: Console",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content :: News/Diary",
+    "Topic :: Text Processing :: Markup",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "apprise>=1.9.3",
+    "click>=8.1.8",
+    "lxml[html-clean]>=5.4.0",
+    "markdown>=3.8",
+    "miniflux>=1.1.3",
+    "newspaper3k>=0.2.8",
+    "pydantic-ai>=0.1.6",
+    "pyyaml>=6.0.2",
+    "structlog>=25.3.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/eikendev/minigist"
+
+[project.scripts]
+minigist = "minigist.cli:cli"
+
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+version_scheme = "post-release"
+local_scheme = "no-local-version"
+
+[dependency-groups]
+dev = [
+    "isort>=6.0.1",
+    "mypy>=1.15.0",
+    "pytest>=8.3.5",
+    "ruff>=0.11.7",
+    "types-markdown>=3.8.0.20250415",
+    "types-pyyaml>=6.0.12.20250402",
+]

minigist-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

minigist-0.1.2/tests/conftest.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+from unittest.mock import mock_open
+
+import pytest
+import yaml
+
+
+@pytest.fixture
+def valid_config_dict():
+    """Fixture providing a valid configuration dictionary."""
+    return {
+        "miniflux": {"url": "https://example.com", "api_key": "test_miniflux_key"},
+        "ai": {
+            "api_key": "test_ai_key",
+            "model": "test-model",
+            "system_prompt": "Test prompt",
+            "base_url": "https://api.test.com",
+        },
+    }
+
+
+@pytest.fixture
+def invalid_config_dict():
+    """Fixture providing an invalid configuration dictionary (missing required fields)."""
+    return {
+        "miniflux": {
+            "url": "https://example.com"
+            # Missing api_key
+        },
+        "ai": {
+            # Missing api_key
+            "model": "test-model"
+        },
+    }
+
+
+@pytest.fixture
+def mock_config_file(valid_config_dict):
+    """Fixture providing a mock file with valid YAML config content."""
+    return mock_open(read_data=yaml.dump(valid_config_dict))
+
+
+@pytest.fixture
+def mock_config_path():
+    """Fixture providing a mock config file path."""
+    return Path("/mock/path/config.yaml")

minigist-0.1.2/tests/unit/test_config.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+from unittest.mock import mock_open, patch
+
+import pytest
+import yaml
+
+from minigist.config import AppConfig, load_app_config, load_config_from_file
+from minigist.exceptions import ConfigError
+
+
+def test_load_config_from_file_success(valid_config_dict):
+    mock_yaml_content = yaml.dump(valid_config_dict)
+    with patch("builtins.open", mock_open(read_data=mock_yaml_content)):
+        result = load_config_from_file(Path("fake_path.yaml"))
+
+    assert result == valid_config_dict
+
+
+def test_load_config_from_file_empty():
+    with patch("builtins.open", mock_open(read_data="")):
+        with pytest.raises(ConfigError, match="Config file is empty"):
+            load_config_from_file(Path("fake_path.yaml"))
+
+
+def test_load_config_from_file_not_found():
+    with patch("builtins.open", side_effect=FileNotFoundError()):
+        with pytest.raises(ConfigError, match="Config file not found"):
+            load_config_from_file(Path("nonexistent.yaml"))
+
+
+def test_load_app_config_success(valid_config_dict, mock_config_path):
+    with patch("minigist.config.find_config_file", return_value=mock_config_path):
+        with patch(
+            "minigist.config.load_config_from_file", return_value=valid_config_dict
+        ):
+            result = load_app_config("some/path")
+
+            assert isinstance(result, AppConfig)
+            assert str(result.miniflux.url) == "https://example.com/"
+            assert result.miniflux.api_key == "test_miniflux_key"
+            assert result.ai.api_key == "test_ai_key"
+            assert result.ai.model == "test-model"
+
+
+def test_load_app_config_validation_error(invalid_config_dict, mock_config_path):
+    with patch("minigist.config.find_config_file", return_value=mock_config_path):
+        with patch(
+            "minigist.config.load_config_from_file", return_value=invalid_config_dict
+        ):
+            with pytest.raises(
+                ConfigError, match="Invalid or incomplete configuration"
+            ):
+                load_app_config("some/path")
+
+
+def test_load_app_config_config_error(mock_config_path):
+    with patch(
+        "minigist.config.find_config_file",
+        side_effect=ConfigError("No valid config file found"),
+    ):
+        with pytest.raises(ConfigError, match="No valid config file found"):
+            load_app_config("some/path")