article-cli 1.0.0__py3-none-any.whl

article_cli/__init__.py

@@ -0,0 +1,20 @@
+"""
+Article CLI - A command-line tool for managing LaTeX articles
+
+This package provides tools for:
+- Git release management with gitinfo2 support
+- Zotero bibliography synchronization
+- LaTeX build file cleanup
+- Git hooks setup
+"""
+
+__version__ = "1.0.0"
+__author__ = "Christophe Prud'homme"
+__email__ = "prudhomm@cemosis.fr"
+
+from .cli import main
+from .config import Config
+from .zotero import ZoteroBibTexUpdater
+from .git_manager import GitManager
+
+__all__ = ["main", "Config", "ZoteroBibTexUpdater", "GitManager"]

article_cli/__main__.py

@@ -0,0 +1,8 @@
+"""
+Allow running article-cli as a module with python -m article_cli
+"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

article_cli/cli.py

@@ -0,0 +1,308 @@
+"""
+Main CLI interface for article-cli
+
+Provides command-line interface for managing LaTeX articles with git and Zotero integration.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Optional
+
+from . import __version__
+from .config import Config
+from .zotero import ZoteroBibTexUpdater, print_error, print_info
+from .git_manager import GitManager
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create and configure the argument parser"""
+    parser = argparse.ArgumentParser(
+        prog="article-cli",
+        description="CLI tool for managing LaTeX articles with git and Zotero integration",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s setup                          # Setup git hooks
+  %(prog)s clean                          # Clean build files
+  %(prog)s create v1.0.0                  # Create release v1.0.0
+  %(prog)s list --count 10                # List 10 recent releases
+  %(prog)s delete v1.0.0                  # Delete release
+  %(prog)s update-bibtex                  # Update from Zotero
+  %(prog)s config create                  # Create sample config file
+
+Environment variables:
+  ZOTERO_API_KEY    : Your Zotero API key (required for update-bibtex)
+  ZOTERO_USER_ID    : Your Zotero user ID
+  ZOTERO_GROUP_ID   : Your Zotero group ID
+        """,
+    )
+
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+
+    parser.add_argument("--config", type=Path, help="Path to configuration file")
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+
+    # Setup command
+    subparsers.add_parser("setup", help="Setup git hooks for gitinfo2")
+
+    # Clean command
+    subparsers.add_parser("clean", help="Clean LaTeX build files")
+
+    # Create command
+    create_parser = subparsers.add_parser("create", help="Create a new release")
+    create_parser.add_argument("version", help="Version tag (e.g., v1.0.0)")
+    create_parser.add_argument(
+        "--push", action="store_true", help="Automatically push the release"
+    )
+
+    # List command
+    list_parser = subparsers.add_parser("list", help="List releases")
+    list_parser.add_argument(
+        "--count", type=int, default=5, help="Number of releases to show"
+    )
+
+    # Delete command
+    delete_parser = subparsers.add_parser("delete", help="Delete a release")
+    delete_parser.add_argument("version", help="Version tag to delete")
+    delete_parser.add_argument(
+        "--remote", action="store_true", help="Also delete from remote"
+    )
+
+    # Update-bibtex command
+    bibtex_parser = subparsers.add_parser(
+        "update-bibtex", help="Update BibTeX from Zotero"
+    )
+    bibtex_parser.add_argument("--api-key", help="Zotero API key")
+    bibtex_parser.add_argument("--user-id", help="Zotero user ID")
+    bibtex_parser.add_argument("--group-id", help="Zotero group ID")
+    bibtex_parser.add_argument(
+        "--output", default="references.bib", help="Output BibTeX file"
+    )
+    bibtex_parser.add_argument(
+        "--no-backup", action="store_true", help="Skip backup creation"
+    )
+
+    # Config command
+    config_parser = subparsers.add_parser("config", help="Configuration management")
+    config_subparsers = config_parser.add_subparsers(
+        dest="config_command", help="Config subcommands"
+    )
+
+    config_create_parser = config_subparsers.add_parser(
+        "create", help="Create sample configuration file"
+    )
+    config_create_parser.add_argument("--path", type=Path, help="Path for config file")
+
+    config_subparsers.add_parser("show", help="Show current configuration")
+
+    return parser
+
+
+def handle_setup_command(config: Config) -> int:
+    """Handle the setup command"""
+    try:
+        git_manager = GitManager()
+        return 0 if git_manager.setup_hooks() else 1
+    except ValueError as e:
+        print_error(str(e))
+        return 1
+
+
+def handle_clean_command(config: Config) -> int:
+    """Handle the clean command"""
+    try:
+        git_manager = GitManager()
+        latex_config = config.get_latex_config()
+        return (
+            0 if git_manager.clean_latex_files(latex_config["clean_extensions"]) else 1
+        )
+    except ValueError as e:
+        print_error(str(e))
+        return 1
+
+
+def handle_create_command(args: argparse.Namespace, config: Config) -> int:
+    """Handle the create command"""
+    try:
+        git_manager = GitManager()
+        git_config = config.get_git_config()
+        auto_push = args.push or git_config.get("auto_push", False)
+        return 0 if git_manager.create_release(args.version, auto_push) else 1
+    except ValueError as e:
+        print_error(str(e))
+        return 1
+
+
+def handle_list_command(args: argparse.Namespace, config: Config) -> int:
+    """Handle the list command"""
+    try:
+        git_manager = GitManager()
+        return 0 if git_manager.list_releases(args.count) else 1
+    except ValueError as e:
+        print_error(str(e))
+        return 1
+
+
+def handle_delete_command(args: argparse.Namespace, config: Config) -> int:
+    """Handle the delete command"""
+    try:
+        git_manager = GitManager()
+        return 0 if git_manager.delete_release(args.version, args.remote) else 1
+    except ValueError as e:
+        print_error(str(e))
+        return 1
+
+
+def handle_update_bibtex_command(args: argparse.Namespace, config: Config) -> int:
+    """Handle the update-bibtex command"""
+    try:
+        # Get and validate Zotero configuration
+        zotero_config = config.validate_zotero_config(args)
+
+        updater = ZoteroBibTexUpdater(
+            api_key=zotero_config["api_key"],
+            user_id=zotero_config["user_id"],
+            group_id=zotero_config["group_id"],
+            output_file=zotero_config["output_file"],
+        )
+
+        return 0 if updater.update(backup=not args.no_backup) else 1
+
+    except ValueError as e:
+        print_error(str(e))
+        return 1
+
+
+def handle_config_command(args: argparse.Namespace, config: Config) -> int:
+    """Handle config subcommands"""
+    if args.config_command == "create":
+        try:
+            path = args.path or Path.cwd() / ".article-cli.toml"
+            config.create_sample_config(path)
+            return 0
+        except Exception as e:
+            print_error(f"Failed to create config file: {e}")
+            return 1
+
+    elif args.config_command == "show":
+        try:
+            print_info("Current configuration:")
+            zotero_config = config.get_zotero_config()
+            git_config = config.get_git_config()
+            latex_config = config.get_latex_config()
+
+            print("\n[Zotero]")
+            print(f"  API Key: {'***' if zotero_config['api_key'] else 'Not set'}")
+            print(f"  User ID: {zotero_config['user_id'] or 'Not set'}")
+
+            # Show group ID with name if available
+            if zotero_config["group_id"]:
+                group_display = zotero_config["group_id"]
+
+                # Try to get group name if API key is available
+                if zotero_config["api_key"]:
+                    try:
+                        from .zotero import ZoteroBibTexUpdater
+
+                        updater = ZoteroBibTexUpdater(
+                            api_key=zotero_config["api_key"],
+                            group_id=zotero_config["group_id"],
+                        )
+                        group_name = updater.get_group_name()
+                        if group_name:
+                            group_display = (
+                                f"{zotero_config['group_id']} ({group_name})"
+                            )
+                    except Exception:
+                        pass  # Silently fall back to just showing ID
+
+                print(f"  Group ID: {group_display}")
+            else:
+                print(f"  Group ID: Not set")
+
+            print(f"  Output File: {zotero_config['output_file']}")
+
+            print("\n[Git]")
+            print(f"  Auto Push: {git_config['auto_push']}")
+            print(f"  Default Branch: {git_config['default_branch']}")
+
+            print("\n[LaTeX]")
+            print(
+                f"  Clean Extensions: {len(latex_config['clean_extensions'])} extensions"
+            )
+            print(f"  Build Directory: {latex_config['build_dir']}")
+
+            return 0
+        except Exception as e:
+            print_error(f"Failed to show configuration: {e}")
+            return 1
+    else:
+        print_error("Unknown config command")
+        return 1
+
+
+def main(argv: Optional[list] = None) -> int:
+    """
+    Main entry point for article-cli
+
+    Args:
+        argv: Command line arguments (defaults to sys.argv)
+
+    Returns:
+        Exit code (0 for success, non-zero for error)
+    """
+    parser = create_parser()
+    args = parser.parse_args(argv)
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    # Initialize configuration
+    try:
+        config = Config(args.config)
+    except Exception as e:
+        print_error(f"Configuration error: {e}")
+        return 1
+
+    # Route to appropriate command handler
+    try:
+        if args.command == "setup":
+            return handle_setup_command(config)
+
+        elif args.command == "clean":
+            return handle_clean_command(config)
+
+        elif args.command == "create":
+            return handle_create_command(args, config)
+
+        elif args.command == "list":
+            return handle_list_command(args, config)
+
+        elif args.command == "delete":
+            return handle_delete_command(args, config)
+
+        elif args.command == "update-bibtex":
+            return handle_update_bibtex_command(args, config)
+
+        elif args.command == "config":
+            return handle_config_command(args, config)
+
+        else:
+            print_error(f"Unknown command: {args.command}")
+            return 1
+
+    except KeyboardInterrupt:
+        print("\n\nInterrupted by user")
+        return 130
+    except Exception as e:
+        print_error(f"Unexpected error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

article_cli/config.py

@@ -0,0 +1,275 @@
+"""
+Configuration management for article-cli
+
+Supports both environment variables and TOML configuration files.
+"""
+
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional, Union
+import argparse
+
+try:
+    import tomllib  # Python 3.11+
+except ImportError:
+    try:
+        import tomli as tomllib  # fallback for older Python versions
+    except ImportError:
+        tomllib = None
+
+
+class Config:
+    """Configuration manager for article-cli"""
+
+    def __init__(self, config_file: Optional[Union[str, Path]] = None):
+        """
+        Initialize configuration manager
+
+        Args:
+            config_file: Optional path to configuration file
+        """
+        self.config_file = config_file
+        self._config_data: Dict[str, Any] = {}
+        self._load_config()
+
+    def _find_config_file(self) -> Optional[Path]:
+        """Find configuration file in project directory"""
+        if self.config_file:
+            config_path = Path(self.config_file)
+            if config_path.exists():
+                return config_path
+            else:
+                raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        # Look for default config files (in priority order)
+        search_paths = [
+            Path.cwd()
+            / ".article-cli.toml",  # Dedicated config file (highest priority)
+            Path.cwd() / "pyproject.toml",  # Project config file
+            Path.cwd() / "article-cli.toml",  # Alternative dedicated file
+            Path.home() / ".config" / "article-cli" / "config.toml",  # XDG config
+            Path.home() / ".article-cli.toml",  # User config (lowest priority)
+        ]
+
+        for path in search_paths:
+            if path.exists():
+                return path
+
+        return None
+
+    def _load_config(self) -> None:
+        """Load configuration from file if it exists"""
+        config_path = self._find_config_file()
+
+        if config_path and tomllib:
+            try:
+                with open(config_path, "rb") as f:
+                    full_config = tomllib.load(f)
+
+                # Handle pyproject.toml vs dedicated config file
+                if config_path.name == "pyproject.toml":
+                    # Extract article-cli config section from pyproject.toml
+                    self._config_data = full_config.get("tool", {}).get(
+                        "article-cli", {}
+                    )
+                    if self._config_data:
+                        print(
+                            f"Loaded configuration from: {config_path} [tool.article-cli]"
+                        )
+                    else:
+                        # Fallback: look for legacy sections at root level
+                        legacy_sections = ["zotero", "git", "latex"]
+                        self._config_data = {
+                            k: v for k, v in full_config.items() if k in legacy_sections
+                        }
+                        if self._config_data:
+                            print(f"Loaded legacy configuration from: {config_path}")
+                else:
+                    # Dedicated config file - use as-is
+                    self._config_data = full_config
+                    print(f"Loaded configuration from: {config_path}")
+
+            except Exception as e:
+                print(f"Warning: Could not load config file {config_path}: {e}")
+                self._config_data = {}
+        elif config_path and not tomllib:
+            print(
+                "Warning: TOML support not available. Install with: pip install tomli"
+            )
+            self._config_data = {}
+        else:
+            self._config_data = {}
+
+    def get(
+        self, section: str, key: str, default: Any = None, env_var: Optional[str] = None
+    ) -> Any:
+        """
+        Get configuration value with priority: CLI args > env vars > config file > default
+
+        Args:
+            section: Configuration section name
+            key: Configuration key name
+            default: Default value if not found
+            env_var: Environment variable name to check
+
+        Returns:
+            Configuration value
+        """
+        # Check environment variable first
+        if env_var and env_var in os.environ:
+            return os.environ[env_var]
+
+        # Check config file
+        if section in self._config_data and key in self._config_data[section]:
+            return self._config_data[section][key]
+
+        return default
+
+    def get_zotero_config(self) -> Dict[str, Optional[str]]:
+        """Get Zotero-specific configuration"""
+        return {
+            "api_key": self.get("zotero", "api_key", env_var="ZOTERO_API_KEY"),
+            "user_id": self.get("zotero", "user_id", env_var="ZOTERO_USER_ID"),
+            "group_id": self.get("zotero", "group_id", env_var="ZOTERO_GROUP_ID"),
+            "output_file": self.get(
+                "zotero", "output_file", "references.bib", env_var="BIBTEX_FILE"
+            ),
+        }
+
+    def get_git_config(self) -> Dict[str, Any]:
+        """Get Git-specific configuration"""
+        return {
+            "auto_push": self.get("git", "auto_push", False),
+            "default_branch": self.get("git", "default_branch", "main"),
+        }
+
+    def get_latex_config(self) -> Dict[str, Any]:
+        """Get LaTeX-specific configuration"""
+        default_extensions = [
+            ".aux",
+            ".bbl",
+            ".blg",
+            ".log",
+            ".out",
+            ".pyg",
+            ".fls",
+            ".synctex.gz",
+            ".toc",
+            ".fdb_latexmk",
+            ".idx",
+            ".ilg",
+            ".ind",
+            ".chl",
+            ".lof",
+            ".lot",
+        ]
+
+        return {
+            "clean_extensions": self.get(
+                "latex", "clean_extensions", default_extensions
+            ),
+            "build_dir": self.get("latex", "build_dir", "."),
+        }
+
+    def validate_zotero_config(
+        self, args: argparse.Namespace
+    ) -> Dict[str, Optional[str]]:
+        """
+        Validate and merge Zotero configuration from args and config
+
+        Args:
+            args: Parsed command line arguments
+
+        Returns:
+            Dict with validated Zotero configuration
+
+        Raises:
+            ValueError: If required configuration is missing
+        """
+        config = self.get_zotero_config()
+
+        # Override with command line arguments
+        if hasattr(args, "api_key") and args.api_key:
+            config["api_key"] = args.api_key
+        if hasattr(args, "user_id") and args.user_id:
+            config["user_id"] = args.user_id
+        if hasattr(args, "group_id") and args.group_id:
+            config["group_id"] = args.group_id
+        if hasattr(args, "output") and args.output:
+            config["output_file"] = args.output
+
+        # Validate required fields
+        if not config["api_key"]:
+            raise ValueError(
+                "Zotero API key is required. Set via:\n"
+                "  - Command line: --api-key YOUR_KEY\n"
+                "  - Environment: export ZOTERO_API_KEY=YOUR_KEY\n"
+                '  - Config file: [zotero] api_key = "YOUR_KEY"'
+            )
+
+        if not config["user_id"] and not config["group_id"]:
+            raise ValueError(
+                "Either Zotero user ID or group ID is required. Set via:\n"
+                "  - Command line: --user-id ID or --group-id ID\n"
+                "  - Environment: export ZOTERO_USER_ID=ID or ZOTERO_GROUP_ID=ID\n"
+                '  - Config file: [zotero] user_id = "ID" or group_id = "ID"'
+            )
+
+        return config
+
+    def create_sample_config(self, path: Optional[Path] = None) -> Path:
+        """
+        Create a sample configuration file
+
+        Args:
+            path: Optional path for config file
+
+        Returns:
+            Path to created config file
+        """
+        if path is None:
+            path = Path.cwd() / ".article-cli.toml"
+
+        sample_config = """# Article CLI Configuration File
+# Copy this file to your project root as .article-cli.toml
+
+[zotero]
+# Your Zotero API key (get from https://www.zotero.org/settings/keys)
+api_key = "your_api_key_here"
+
+# Either user_id OR group_id (not both)
+# user_id = "your_user_id"
+group_id = "6219333"
+
+# Output file for bibliography
+output_file = "references.bib"
+
+[git]
+# Automatically push after creating releases
+auto_push = true
+
+# Default branch name
+default_branch = "main"
+
+[latex]
+# File extensions to clean
+clean_extensions = [
+    ".aux", ".bbl", ".blg", ".log", ".out", ".pyg",
+    ".fls", ".synctex.gz", ".toc", ".fdb_latexmk",
+    ".idx", ".ilg", ".ind", ".chl", ".lof", ".lot"
+]
+
+# Build directory (relative to project root)
+build_dir = "."
+"""
+
+        try:
+            with open(path, "w") as f:
+                f.write(sample_config)
+            print(f"Created sample configuration file: {path}")
+            return path
+        except Exception as e:
+            raise RuntimeError(f"Could not create config file {path}: {e}")
+
+    def __repr__(self) -> str:
+        return f"Config(config_file={self.config_file}, sections={list(self._config_data.keys())})"