igntui 0.0.0__py3-none-any.whl

igntui/__init__.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import platform
+import sys
+
+__version__ = "0.0.0"
+__author__ = "Mohammad Abu Mattar"
+__email__ = "info@mkabumattar.com"
+__description__ = """A professional TUI application for generating .gitignore files from templates
+provided by gitignore.io with advanced search, caching, and performance features.
+"""
+
+
+def get_version_string() -> str:
+    python_version = (
+        f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    )
+    os_name = platform.system()
+    os_version = platform.release()
+    return f"igntui/{__version__} Python/{python_version} {os_name}/{os_version}"
+
+
+from .core.api import GitIgnoreAPI, APIResponse
+from .core.config import config
+from .core.search import SearchManager, SearchMode
+from .core.cache import CacheManager, TemplateCache
+
+from .main import cli_main, tui_main
+
+try:
+    from .app import run_tui
+
+    TUI_AVAILABLE = True
+except ImportError:
+    run_tui = None
+    TUI_AVAILABLE = False
+
+__all__ = [
+    "__version__",
+    "__author__",
+    "__email__",
+    "__description__",
+    "get_version_string",
+    "GitIgnoreAPI",
+    "APIResponse",
+    "config",
+    "SearchManager",
+    "SearchMode",
+    "CacheManager",
+    "TemplateCache",
+    "cli_main",
+    "tui_main",
+    "run_tui",
+    "TUI_AVAILABLE",
+]

igntui/__main__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import sys
+
+from .main import cli_main
+
+if __name__ == "__main__":
+    cli_main()

igntui/app.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import curses
+import sys
+from typing import Optional
+
+
+def run_tui(show_splash: bool = True) -> int:
+    try:
+        from .tui import GitIgnoreTUI
+
+        def main(stdscr):
+            tui = GitIgnoreTUI(stdscr, show_splash=show_splash)
+            return tui.run()
+
+        exit_code = curses.wrapper(main)
+        return exit_code if exit_code is not None else 0
+
+    except ImportError as e:
+        if "curses" in str(e):
+            print("Error: curses module not available.")
+            print("On Windows, install: pip install windows-curses")
+            return 1
+        else:
+            raise
+    except KeyboardInterrupt:
+        print("\nOperation cancelled by user")
+        return 1
+    except Exception as e:
+        print(f"Error running TUI: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(run_tui())

igntui/cli/__init__.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from .base import BaseCLI, CLICommand, safe_exit
+from .setup import setup_logging, check_curses_availability, print_curses_error
+from .parser import create_base_parser, create_command_parser, get_command_instance
+from .commands import (
+    ListCommand,
+    GenerateCommand,
+    TUICommand,
+    CacheCommand,
+    TestCommand,
+)
+
+__all__ = [
+    "BaseCLI",
+    "CLICommand",
+    "safe_exit",
+    "setup_logging",
+    "check_curses_availability",
+    "print_curses_error",
+    "create_base_parser",
+    "create_command_parser",
+    "get_command_instance",
+    "ListCommand",
+    "GenerateCommand",
+    "TUICommand",
+    "CacheCommand",
+    "TestCommand",
+]

igntui/cli/base.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import argparse
+import logging
+import sys
+from typing import List, Optional
+
+from .. import __version__, get_version_string
+from ..core.api import GitIgnoreAPI
+from ..core.config import Config
+
+logger = logging.getLogger(__name__)
+
+
+class BaseCLI:
+    def __init__(self):
+        self.config = Config()
+        self.api = GitIgnoreAPI()
+
+    def setup_logging(self, verbose: bool = False):
+        level = logging.DEBUG if verbose else logging.INFO
+        logging.basicConfig(
+            level=level, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+
+    def check_terminal_requirements(self) -> bool:
+        try:
+            import curses
+
+            stdscr = curses.initscr()
+            curses.endwin()
+            return True
+        except ImportError:
+            print("Error: curses module not available.")
+            print("On Windows, install: pip install windows-curses")
+            return False
+        except Exception as e:
+            print(f"Error: Terminal not compatible with curses: {e}")
+            return False
+
+    def handle_api_error(self, error: Exception) -> None:
+        if "connection" in str(error).lower() or "timeout" in str(error).lower():
+            print("Error: Cannot connect to gitignore.io API")
+            print("Please check your internet connection and try again.")
+        elif "not found" in str(error).lower() or "404" in str(error):
+            print("Error: Template not found")
+            print("Use 'igntui list' to see available templates.")
+        else:
+            print(f"Error: {error}")
+
+        logger.error(f"API error: {error}")
+
+
+class CLICommand:
+    def __init__(self, cli: BaseCLI):
+        self.cli = cli
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        raise NotImplementedError
+
+    def execute(self, args: argparse.Namespace) -> int:
+        raise NotImplementedError
+
+
+def create_base_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="igntui",
+        description="Interactive TUI for generating .gitignore files from gitignore.io templates",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  igntui                    # Launch interactive TUI
+  igntui list               # List available templates  
+  igntui generate python    # Generate .gitignore for Python
+  igntui test               # Test API connection
+  
+For more information, visit: https://github.com/toptal/gitignore.io
+        """,
+    )
+
+    parser.add_argument("--version", action="version", version=get_version_string())
+
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Enable verbose output"
+    )
+
+    parser.add_argument(
+        "--no-color", action="store_true", help="Disable colored output"
+    )
+
+    return parser
+
+
+def safe_exit(code: int = 0) -> None:
+    try:
+        import curses
+
+        curses.endwin()
+    except:
+        pass
+
+    sys.exit(code)

igntui/cli/commands/__init__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from .list_cmd import ListCommand
+from .generate_cmd import GenerateCommand
+from .tui_cmd import TUICommand
+from .cache_cmd import CacheCommand
+from .test_cmd import TestCommand
+
+__all__ = [
+    "ListCommand",
+    "GenerateCommand",
+    "TUICommand",
+    "CacheCommand",
+    "TestCommand",
+]

igntui/cli/commands/cache_cmd.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import argparse
+from datetime import datetime
+
+from ..base import CLICommand
+
+
+class CacheCommand(CLICommand):
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        subparsers = parser.add_subparsers(dest="cache_action", help="Cache action")
+
+        clear_parser = subparsers.add_parser("clear", help="Clear cache")
+        clear_parser.add_argument(
+            "--force", action="store_true", help="Skip confirmation prompt"
+        )
+
+        subparsers.add_parser("stats", help="Show cache statistics")
+        subparsers.add_parser("info", help="Show cache information")
+
+    def execute(self, args: argparse.Namespace) -> int:
+        try:
+            from ...core.cache import CacheManager
+            from ...core.config import config
+
+            cache_dir = config.get_cache_dir()
+            cache = CacheManager(cache_dir=str(cache_dir))
+
+            if not args.cache_action or args.cache_action == "info":
+                return self._show_info(cache)
+            elif args.cache_action == "stats":
+                return self._show_stats(cache)
+            elif args.cache_action == "clear":
+                return self._clear_cache(
+                    cache, args.force if hasattr(args, "force") else False
+                )
+            else:
+                print(f"Unknown cache action: {args.cache_action}")
+                return 1
+
+        except Exception as e:
+            print(f"Error managing cache: {e}")
+            if hasattr(args, "verbose") and args.verbose:
+                import traceback
+
+                traceback.print_exc()
+            return 1
+
+    def _show_info(self, cache: "CacheManager") -> int:
+        print("Cache Information:")
+        print(f"  Location: {cache.cache_dir}")
+        print(f"  TTL: {cache.default_ttl} seconds")
+
+        try:
+            from pathlib import Path
+
+            template_cache_file = Path(cache.cache_dir) / "templates.json"
+            if template_cache_file.exists():
+                import json
+
+                with open(template_cache_file, "r") as f:
+                    data = json.load(f)
+                    templates = data.get("templates", [])
+                    print(f"  Template cache: Valid")
+                    print(f"  Templates cached: {len(templates)}")
+            else:
+                print(f"  Template cache: Not found")
+        except Exception as e:
+            print(f"  Template cache: Error reading ({e})")
+
+        return 0
+
+    def _show_stats(self, cache: "CacheManager") -> int:
+        stats = cache.get_stats()
+
+        print("Cache Statistics:")
+        for key, value in stats.items():
+            if isinstance(value, datetime):
+                value = value.strftime("%Y-%m-%d %H:%M:%S")
+            print(f"  {key}: {value}")
+
+        return 0
+
+    def _clear_cache(self, cache: "CacheManager", force: bool = False) -> int:
+        if not force:
+            response = input("Clear cache? This will remove all cached data. (y/N): ")
+            if response.lower() not in ["y", "yes"]:
+                print("Cache clear cancelled")
+                return 1
+
+        cache.clear_all()
+        print("Cache cleared successfully")
+        return 0

igntui/cli/commands/generate_cmd.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import argparse
+import os
+from pathlib import Path
+
+from ..base import CLICommand
+
+
+class GenerateCommand(CLICommand):
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "templates", nargs="+", help="Template names to generate (space-separated)"
+        )
+        parser.add_argument(
+            "--output",
+            "-o",
+            type=Path,
+            metavar="FILE",
+            help="Output file path (default: print to stdout)",
+        )
+        parser.add_argument(
+            "--append",
+            "-a",
+            action="store_true",
+            help="Append to existing file instead of overwriting",
+        )
+        parser.add_argument(
+            "--force",
+            "-f",
+            action="store_true",
+            help="Force overwrite without confirmation",
+        )
+
+    def execute(self, args: argparse.Namespace) -> int:
+        try:
+            if hasattr(args, "verbose") and args.verbose:
+                print(f"Generating .gitignore for: {', '.join(args.templates)}")
+
+            response = self.cli.api.get_templates(args.templates)
+
+            if not response.success:
+                print(f"Error: {response.error_message}")
+                return 1
+
+            content = response.data
+
+            if not content.strip():
+                print("Warning: Generated content is empty")
+                return 1
+
+            if not args.output:
+                print(content)
+                return 0
+
+            output_file = args.output
+
+            if output_file.exists() and not args.append and not args.force:
+                response_text = input(
+                    f"File '{output_file}' exists. Overwrite? (y/N): "
+                )
+                if response_text.lower() not in ("y", "yes"):
+                    print("Operation cancelled")
+                    return 1
+
+            mode = "a" if args.append else "w"
+            try:
+                with open(output_file, mode, encoding="utf-8") as f:
+                    if args.append and output_file.stat().st_size > 0:
+                        f.write("\n\n# Generated by igntui\n")
+                    f.write(content)
+
+                action = "Appended to" if args.append else "Generated"
+                print(f"✓ {action} {output_file}")
+                return 0
+
+            except IOError as e:
+                print(f"Error writing file: {e}")
+                return 1
+
+        except Exception as e:
+            self.cli.handle_api_error(e)
+            return 1

igntui/cli/commands/list_cmd.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import argparse
+
+from ..base import CLICommand
+
+
+class ListCommand(CLICommand):
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "--filter", "-f", metavar="PATTERN", help="Filter templates by pattern"
+        )
+        parser.add_argument(
+            "--count", "-c", action="store_true", help="Show count only"
+        )
+
+    def execute(self, args: argparse.Namespace) -> int:
+        try:
+            if hasattr(args, "verbose") and args.verbose:
+                print("Fetching templates from gitignore.io...")
+
+            response = self.cli.api.list_templates()
+
+            if not response.success:
+                print(f"Error: {response.error_message}")
+                return 1
+
+            templates = response.data
+
+            if hasattr(args, "filter") and args.filter:
+                pattern = args.filter.lower()
+                templates = [t for t in templates if pattern in t.lower()]
+
+            if hasattr(args, "count") and args.count:
+                print(f"Found {len(templates)} templates")
+                return 0
+
+            if not templates:
+                if hasattr(args, "filter") and args.filter:
+                    print(f"No templates found matching '{args.filter}'")
+                else:
+                    print("No templates found")
+                return 1
+
+            print(f"Available templates ({len(templates)}):")
+            print()
+
+            max_width = 80
+            col_width = max(len(t) for t in templates) + 2
+            cols = max(1, max_width // col_width)
+
+            for i, template in enumerate(templates):
+                print(f"{template:<{col_width}}", end="")
+                if (i + 1) % cols == 0:
+                    print()
+
+            if len(templates) % cols != 0:
+                print()
+
+            return 0
+
+        except Exception as e:
+            self.cli.handle_api_error(e)
+            return 1

igntui/cli/commands/test_cmd.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import argparse
+import sys
+
+from ..base import CLICommand
+
+
+class TestCommand(CLICommand):
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "--timeout",
+            type=int,
+            default=10,
+            help="Connection timeout in seconds (default: 10)",
+        )
+
+    def execute(self, args: argparse.Namespace) -> int:
+        try:
+            from ...core.api import GitIgnoreAPI
+
+            print("Testing connection to gitignore.io API...")
+            print(f"Timeout: {args.timeout} seconds")
+            print()
+
+            api = GitIgnoreAPI()
+
+            print("Attempting to connect...", end="", flush=True)
+            response = api.test_connection()
+
+            if not response.success:
+                print(" FAILED")
+                print(f"Error: {response.error_message}")
+                return 1
+
+            print(" SUCCESS")
+            print()
+
+            print("API Response:")
+            response_time = (
+                response.response_time if response.response_time is not None else 0.0
+            )
+            print(f"  Response time: {response_time:.3f}s")
+            print(f"  From cache: {'Yes' if response.from_cache else 'No'}")
+            print(
+                f"  Status code: {response.status_code if response.status_code else 'N/A'}"
+            )
+
+            print()
+            print("✓ API is working correctly")
+            return 0
+
+        except KeyboardInterrupt:
+            print("\n\nOperation cancelled by user")
+            return 1
+        except Exception as e:
+            print(f"\n\nError testing API: {e}")
+            if hasattr(args, "verbose") and args.verbose:
+                import traceback
+
+                traceback.print_exc()
+            return 1

igntui/cli/commands/tui_cmd.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import argparse
+
+from ..base import CLICommand
+
+
+class TUICommand(CLICommand):
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument(
+            "--no-splash", action="store_true", help="Skip splash screen on startup"
+        )
+
+    def execute(self, args: argparse.Namespace) -> int:
+        if not self.cli.check_terminal_requirements():
+            return 1
+
+        try:
+            from ...app import run_tui
+
+            return run_tui(show_splash=not args.no_splash)
+
+        except KeyboardInterrupt:
+            print("\nOperation cancelled by user")
+            return 1
+        except Exception as e:
+            print(f"Error launching TUI: {e}")
+            if hasattr(args, "verbose") and args.verbose:
+                import traceback
+
+                traceback.print_exc()
+            return 1