devsync 0.5.5__py3-none-any.whl

aiconfigkit/utils/ui.py

@@ -0,0 +1,194 @@
+"""UI utilities for terminal output."""
+
+from typing import Optional
+
+from rich.console import Console
+from rich.table import Table
+
+from aiconfigkit.core.models import InstallationRecord, Instruction, InstructionBundle
+
+
+def format_instructions_table(
+    instructions: list[Instruction], bundles: list[InstructionBundle], show_bundles: bool = True
+) -> Table:
+    """
+    Format instructions and bundles as a Rich table.
+
+    Args:
+        instructions: List of instructions to display
+        bundles: List of bundles to display
+        show_bundles: Whether to show bundles section
+
+    Returns:
+        Rich Table object
+    """
+    table = Table(title="Available Instructions", show_header=True, header_style="bold cyan")
+
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Type", style="magenta")
+    table.add_column("Description")
+    table.add_column("Tags", style="yellow")
+
+    # Add instructions
+    for inst in sorted(instructions, key=lambda x: x.name):
+        tags_str = ", ".join(inst.tags) if inst.tags else "-"
+        table.add_row(inst.name, "Instruction", inst.description, tags_str)
+
+    # Add bundles
+    if show_bundles:
+        for bundle in sorted(bundles, key=lambda x: x.name):
+            tags_str = ", ".join(bundle.tags) if bundle.tags else "-"
+            inst_count = f"{len(bundle.instructions)} instructions"
+            table.add_row(bundle.name, "Bundle", f"{bundle.description} ({inst_count})", tags_str)
+
+    return table
+
+
+def format_installed_table(records: list[InstallationRecord], group_by_tool: bool = True) -> Table:
+    """
+    Format installed instructions as a Rich table.
+
+    Args:
+        records: List of installation records
+        group_by_tool: Whether to group by AI tool
+
+    Returns:
+        Rich Table object
+    """
+    table = Table(title="Installed Instructions", show_header=True, header_style="bold green")
+
+    if group_by_tool:
+        table.add_column("AI Tool", style="cyan", no_wrap=True)
+
+    table.add_column("Instruction", style="green", no_wrap=True)
+    table.add_column("Scope", style="blue", no_wrap=True)
+    table.add_column("Source Repository")
+    table.add_column("Version", style="magenta", no_wrap=True)
+    table.add_column("Installed", style="yellow")
+    table.add_column("Bundle", style="dim")
+
+    # Sort records
+    if group_by_tool:
+        sorted_records = sorted(records, key=lambda x: (x.ai_tool.value, x.instruction_name))
+    else:
+        sorted_records = sorted(records, key=lambda x: x.instruction_name)
+
+    # Add rows
+    current_tool = None
+    for record in sorted_records:
+        # Format installed date
+        installed_date = record.installed_at.strftime("%Y-%m-%d")
+
+        # Shorten repo URL for display
+        repo_display = _shorten_url(record.source_repo, max_length=50)
+
+        # Bundle name or "-"
+        bundle_display = record.bundle_name if record.bundle_name else "-"
+
+        # Scope display
+        scope_display = record.scope.value.capitalize()
+
+        # Version display with badge
+        if record.source_ref and record.source_ref_type:
+            ref_type_badges = {
+                "tag": "📌",
+                "branch": "🌿",
+                "commit": "📍",
+            }
+            badge = ref_type_badges.get(record.source_ref_type.value, "")
+            version_display = f"{badge} {record.source_ref}"
+        else:
+            version_display = "-"
+
+        if group_by_tool:
+            # Show tool name only on first occurrence
+            tool_display = record.ai_tool.value.capitalize() if record.ai_tool != current_tool else ""
+            current_tool = record.ai_tool
+
+            table.add_row(
+                tool_display,
+                record.instruction_name,
+                scope_display,
+                repo_display,
+                version_display,
+                installed_date,
+                bundle_display,
+            )
+        else:
+            table.add_row(
+                record.instruction_name, scope_display, repo_display, version_display, installed_date, bundle_display
+            )
+
+    return table
+
+
+def format_bundle_details(bundle: InstructionBundle, instructions: list[Instruction]) -> Table:
+    """
+    Format bundle details with its instructions.
+
+    Args:
+        bundle: Bundle to display
+        instructions: Instructions in the bundle
+
+    Returns:
+        Rich Table object
+    """
+    table = Table(title=f"Bundle: {bundle.name}", show_header=True, header_style="bold cyan")
+
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Instruction", style="cyan")
+    table.add_column("Description")
+    table.add_column("Tags", style="yellow")
+
+    for idx, inst in enumerate(instructions, 1):
+        tags_str = ", ".join(inst.tags) if inst.tags else "-"
+        table.add_row(str(idx), inst.name, inst.description, tags_str)
+
+    return table
+
+
+def print_success(message: str, console: Optional[Console] = None) -> None:
+    """Print success message."""
+    if console is None:
+        console = Console()
+    console.print(f"[green]✓[/green] {message}")
+
+
+def print_error(message: str, console: Optional[Console] = None) -> None:
+    """Print error message."""
+    if console is None:
+        console = Console()
+    console.print(f"[red]Error:[/red] {message}")
+
+
+def print_warning(message: str, console: Optional[Console] = None) -> None:
+    """Print warning message."""
+    if console is None:
+        console = Console()
+    console.print(f"[yellow]Warning:[/yellow] {message}")
+
+
+def print_info(message: str, console: Optional[Console] = None) -> None:
+    """Print info message."""
+    if console is None:
+        console = Console()
+    console.print(f"[cyan]ℹ[/cyan] {message}")
+
+
+def _shorten_url(url: str, max_length: int = 50) -> str:
+    """Shorten URL for display."""
+    if len(url) <= max_length:
+        return url
+
+    # Try to keep the important parts: domain and repo name
+    if "://" in url:
+        protocol, rest = url.split("://", 1)
+        if "/" in rest:
+            parts = rest.split("/")
+            if len(parts) >= 3:
+                # Keep domain and last 2 parts
+                shortened = f"{parts[0]}/.../{'/'.join(parts[-2:])}"
+                return shortened
+
+    # Fallback: truncate with ellipsis
+    return url[: max_length - 3] + "..."

aiconfigkit/utils/validation.py

@@ -0,0 +1,187 @@
+"""Input validation utilities for CLI arguments and data."""
+
+import re
+from typing import Optional
+from urllib.parse import urlparse
+
+
+def is_valid_git_url(url: str) -> bool:
+    """
+    Validate if a string is a valid Git repository URL or local path.
+
+    Supports:
+    - HTTPS: https://github.com/user/repo.git
+    - SSH: git@github.com:user/repo.git
+    - Git protocol: git://github.com/user/repo.git
+    - File: file:///path/to/repo
+    - Local absolute paths: /path/to/repo
+    - Local relative paths: ./path/to/repo or ../path/to/repo or path/to/repo
+    """
+    if not url or not isinstance(url, str):
+        return False
+
+    # HTTPS URLs
+    if url.startswith(("https://", "http://")):
+        try:
+            parsed = urlparse(url)
+            return bool(parsed.netloc and parsed.path)
+        except Exception:
+            return False
+
+    # SSH URLs (git@host:path)
+    ssh_pattern = r"^[\w\-\.]+@[\w\-\.]+:[\w\-\.\/]+$"
+    if "@" in url and ":" in url:
+        return bool(re.match(ssh_pattern, url))
+
+    # Git protocol URLs
+    if url.startswith("git://"):
+        try:
+            parsed = urlparse(url)
+            return bool(parsed.netloc and parsed.path)
+        except Exception:
+            return False
+
+    # File URLs and local paths (absolute and relative)
+    if url.startswith(("file://", "/", "./", "../")):
+        return True
+
+    # Relative paths without ./ prefix (e.g., "my-repo" or "path/to/repo")
+    # Check if it looks like a local path (no protocol, no @host:)
+    if "://" not in url and "@" not in url:
+        return True
+
+    return False
+
+
+def is_valid_instruction_name(name: str) -> bool:
+    """
+    Validate instruction name follows naming conventions.
+
+    Rules:
+    - Only lowercase letters, numbers, hyphens
+    - Must start with letter
+    - 3-50 characters
+    """
+    if not name or not isinstance(name, str):
+        return False
+
+    pattern = r"^[a-z][a-z0-9\-]{2,49}$"
+    return bool(re.match(pattern, name))
+
+
+def is_valid_tag(tag: str) -> bool:
+    """
+    Validate tag format.
+
+    Rules:
+    - Only lowercase letters, numbers, hyphens
+    - 2-30 characters
+    """
+    if not tag or not isinstance(tag, str):
+        return False
+
+    pattern = r"^[a-z0-9\-]{2,30}$"
+    return bool(re.match(pattern, tag))
+
+
+def is_valid_checksum(checksum: str, algorithm: str = "sha256") -> bool:
+    """
+    Validate checksum format.
+
+    Args:
+        checksum: The checksum string to validate
+        algorithm: Hash algorithm (sha256, sha1, md5)
+    """
+    if not checksum or not isinstance(checksum, str):
+        return False
+
+    expected_lengths = {
+        "sha256": 64,
+        "sha1": 40,
+        "md5": 32,
+    }
+
+    expected_length = expected_lengths.get(algorithm.lower())
+    if not expected_length:
+        return False
+
+    # Checksum should be hex string of expected length
+    pattern = f"^[a-f0-9]{{{expected_length}}}$"
+    return bool(re.match(pattern, checksum.lower()))
+
+
+def sanitize_instruction_name(name: str) -> str:
+    """
+    Sanitize an instruction name to make it valid.
+
+    Converts to lowercase, replaces invalid chars with hyphens,
+    removes leading/trailing hyphens.
+    """
+    # Convert to lowercase
+    sanitized = name.lower()
+
+    # Replace invalid characters with hyphens
+    sanitized = re.sub(r"[^a-z0-9\-]", "-", sanitized)
+
+    # Remove leading/trailing hyphens
+    sanitized = sanitized.strip("-")
+
+    # Collapse multiple consecutive hyphens
+    sanitized = re.sub(r"-+", "-", sanitized)
+
+    # Ensure starts with letter
+    if sanitized and not sanitized[0].isalpha():
+        sanitized = "inst-" + sanitized
+
+    # Truncate to max length
+    if len(sanitized) > 50:
+        sanitized = sanitized[:50].rstrip("-")
+
+    return sanitized
+
+
+def validate_file_path(path: str) -> Optional[str]:
+    """
+    Validate file path is safe (no directory traversal).
+
+    Returns:
+        None if valid, error message if invalid
+    """
+    if not path or not isinstance(path, str):
+        return "Path must be a non-empty string"
+
+    # Check for directory traversal attempts
+    if ".." in path:
+        return "Path cannot contain '..' (directory traversal)"
+
+    # Check for absolute paths
+    if path.startswith("/") or (len(path) > 1 and path[1] == ":"):
+        return "Path must be relative (not absolute)"
+
+    # Check for unsafe characters
+    unsafe_chars = ["<", ">", "|", "\0"]
+    for char in unsafe_chars:
+        if char in path:
+            return f"Path contains unsafe character: {char}"
+
+    return None
+
+
+def normalize_repo_url(url: str) -> str:
+    """
+    Normalize repository URL for consistent comparison.
+
+    - Removes trailing .git
+    - Removes trailing slashes
+    - Converts to lowercase for hostname
+    """
+    normalized = url.strip()
+
+    # Remove trailing slashes first
+    normalized = normalized.rstrip("/")
+
+    # Remove trailing .git
+    if normalized.endswith(".git"):
+        normalized = normalized[:-4]
+
+    return normalized

devsync-0.5.5.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 InstructionKit Team
+
+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.