fixdoc 0.0.1__py3-none-any.whl

fixdoc/git.py

@@ -0,0 +1,263 @@
+"""Git operations wrapper for fixdoc sync."""
+
+import subprocess
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Optional, Tuple
+
+
+class GitError(Exception):
+    """Raised when a git operation fails."""
+
+    def __init__(self, message: str, stderr: str = ""):
+        self.message = message
+        self.stderr = stderr
+        super().__init__(f"{message}: {stderr}" if stderr else message)
+
+
+class SyncStatus(Enum):
+    """Status of local repo relative to remote."""
+
+    UP_TO_DATE = "up_to_date"
+    AHEAD = "ahead"
+    BEHIND = "behind"
+    DIVERGED = "diverged"
+    NOT_INITIALIZED = "not_initialized"
+    NO_REMOTE = "no_remote"
+
+
+@dataclass
+class GitStatusInfo:
+    """Detailed git status information."""
+
+    status: SyncStatus
+    commits_ahead: int = 0
+    commits_behind: int = 0
+    local_changes: list[str] = field(default_factory=list)
+
+
+class GitOperations:
+    """Encapsulates git subprocess operations."""
+
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+
+    def _run(
+        self, *args: str, check: bool = True, capture_output: bool = True
+    ) -> subprocess.CompletedProcess:
+        """Execute a git command in the repo directory."""
+        cmd = ["git"] + list(args)
+        try:
+            result = subprocess.run(
+                cmd,
+                cwd=self.repo_path,
+                capture_output=capture_output,
+                text=True,
+                check=False,
+            )
+            if check and result.returncode != 0:
+                raise GitError(f"Git command failed: {' '.join(cmd)}", result.stderr)
+            return result
+        except FileNotFoundError:
+            raise GitError("Git is not installed or not in PATH")
+
+    def is_git_repo(self) -> bool:
+        """Check if directory is a git repository."""
+        result = self._run("rev-parse", "--git-dir", check=False)
+        return result.returncode == 0
+
+    def init(self) -> None:
+        """Initialize a new git repository."""
+        self._run("init")
+
+    def clone(self, url: str, branch: str = "main") -> None:
+        """Clone a remote repository into the repo path."""
+        parent = self.repo_path.parent
+        name = self.repo_path.name
+        subprocess.run(
+            ["git", "clone", "-b", branch, url, name],
+            cwd=parent,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+    def add(self, *paths: str) -> None:
+        """Stage files for commit."""
+        if not paths:
+            return
+        self._run("add", *paths)
+
+    def add_all(self) -> None:
+        """Stage all changes."""
+        self._run("add", "-A")
+
+    def commit(self, message: str, author: Optional[str] = None) -> str:
+        """Create a commit, return commit hash."""
+        args = ["commit", "-m", message]
+        if author:
+            args.extend(["--author", author])
+
+        result = self._run(*args)
+        hash_result = self._run("rev-parse", "HEAD")
+        return hash_result.stdout.strip()
+
+    def push(self, remote: str = "origin", branch: str = "main") -> None:
+        """Push commits to remote."""
+        self._run("push", "-u", remote, branch)
+
+    def pull(
+        self, remote: str = "origin", branch: str = "main"
+    ) -> Tuple[bool, list[str]]:
+        """
+        Pull from remote.
+        Returns (had_conflicts, conflicted_files).
+        """
+        result = self._run("pull", remote, branch, check=False)
+
+        if result.returncode != 0:
+            if "CONFLICT" in result.stdout or "CONFLICT" in result.stderr:
+                conflict_files = self._get_conflict_files()
+                return (True, conflict_files)
+            raise GitError("Pull failed", result.stderr)
+
+        return (False, [])
+
+    def _get_conflict_files(self) -> list[str]:
+        """Get list of files with merge conflicts."""
+        result = self._run("diff", "--name-only", "--diff-filter=U", check=False)
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip().split("\n")
+        return []
+
+    def fetch(self, remote: str = "origin") -> None:
+        """Fetch from remote without merging."""
+        self._run("fetch", remote)
+
+    def remote_add(self, name: str, url: str) -> None:
+        """Add a remote."""
+        self._run("remote", "add", name, url)
+
+    def remote_get_url(self, name: str = "origin") -> Optional[str]:
+        """Get remote URL."""
+        result = self._run("remote", "get-url", name, check=False)
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return None
+
+    def remote_set_url(self, name: str, url: str) -> None:
+        """Set remote URL."""
+        self._run("remote", "set-url", name, url)
+
+    def has_remote(self, name: str = "origin") -> bool:
+        """Check if a remote exists."""
+        result = self._run("remote", "get-url", name, check=False)
+        return result.returncode == 0
+
+    def get_status(self, remote: str = "origin", branch: str = "main") -> GitStatusInfo:
+        """Get sync status relative to remote."""
+        if not self.is_git_repo():
+            return GitStatusInfo(status=SyncStatus.NOT_INITIALIZED)
+
+        if not self.has_remote(remote):
+            return GitStatusInfo(status=SyncStatus.NO_REMOTE)
+
+        self.fetch(remote)
+
+        ahead = self._count_commits(f"{remote}/{branch}..HEAD")
+        behind = self._count_commits(f"HEAD..{remote}/{branch}")
+        local_changes = self.get_changed_files()
+
+        if ahead > 0 and behind > 0:
+            status = SyncStatus.DIVERGED
+        elif ahead > 0:
+            status = SyncStatus.AHEAD
+        elif behind > 0:
+            status = SyncStatus.BEHIND
+        else:
+            status = SyncStatus.UP_TO_DATE
+
+        return GitStatusInfo(
+            status=status,
+            commits_ahead=ahead,
+            commits_behind=behind,
+            local_changes=local_changes,
+        )
+
+    def _count_commits(self, range_spec: str) -> int:
+        """Count commits in a range."""
+        result = self._run("rev-list", "--count", range_spec, check=False)
+        if result.returncode == 0:
+            try:
+                return int(result.stdout.strip())
+            except ValueError:
+                return 0
+        return 0
+
+    def get_changed_files(self) -> list[str]:
+        """Get list of modified/added/untracked files."""
+        result = self._run("status", "--porcelain", check=False)
+        if result.returncode == 0 and result.stdout.strip():
+            files = []
+            for line in result.stdout.strip().split("\n"):
+                if line:
+                    files.append(line[3:])
+            return files
+        return []
+
+    def has_uncommitted_changes(self) -> bool:
+        """Check if there are uncommitted changes."""
+        result = self._run("status", "--porcelain", check=False)
+        return bool(result.stdout.strip())
+
+    def get_current_branch(self) -> Optional[str]:
+        """Get the current branch name."""
+        result = self._run("branch", "--show-current", check=False)
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return None
+
+    def checkout_branch(self, branch: str, create: bool = False) -> None:
+        """Checkout a branch."""
+        if create:
+            self._run("checkout", "-b", branch)
+        else:
+            self._run("checkout", branch)
+
+    def stash(self) -> bool:
+        """Stash current changes. Returns True if something was stashed."""
+        result = self._run("stash", check=False)
+        return "No local changes" not in result.stdout
+
+    def stash_pop(self) -> None:
+        """Pop the most recent stash."""
+        self._run("stash", "pop", check=False)
+
+    def reset_hard(self, ref: str = "HEAD") -> None:
+        """Hard reset to a reference."""
+        self._run("reset", "--hard", ref)
+
+    def get_file_content_at_ref(self, filepath: str, ref: str) -> Optional[str]:
+        """Get file contents at a specific revision."""
+        result = self._run("show", f"{ref}:{filepath}", check=False)
+        if result.returncode == 0:
+            return result.stdout
+        return None
+
+    def get_last_commit_message(self) -> Optional[str]:
+        """Get the last commit message."""
+        result = self._run("log", "-1", "--pretty=%B", check=False)
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return None
+
+    def is_git_available() -> bool:
+        """Check if git is available on the system."""
+        try:
+            subprocess.run(
+                ["git", "--version"], capture_output=True, text=True, check=True
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False

fixdoc/markdown_parser.py

@@ -0,0 +1,106 @@
+"""Markdown parsing for fixes - reverse of formatter.py."""
+
+import re
+from typing import Optional
+
+from .models import Fix
+
+
+class MarkdownParseError(Exception):
+    """Raised when markdown parsing fails."""
+
+    pass
+
+
+def markdown_to_fix(content: str, fix_id: str) -> Fix:
+    """
+    Parse markdown content back into a Fix object.
+
+    Expected format matches output of fix_to_markdown():
+    - Header: # Fix: {short_id}
+    - Metadata: **Created:** ... **Updated:** ... **Author:** ...
+    - Sections: ## Issue, ## Resolution, ## Error Excerpt, ## Notes
+    """
+    created_at = _extract_metadata(content, "Created")
+    updated_at = _extract_metadata(content, "Updated")
+    author = _extract_metadata(content, "Author")
+    author_email = _extract_metadata(content, "Author Email")
+    tags = _extract_tags(content)
+
+    issue = _extract_section(content, "Issue")
+    resolution = _extract_section(content, "Resolution")
+    error_excerpt = _extract_code_block(content, "Error Excerpt")
+    notes = _extract_section(content, "Notes")
+
+    if not issue:
+        raise MarkdownParseError("Missing required 'Issue' section")
+    if not resolution:
+        raise MarkdownParseError("Missing required 'Resolution' section")
+
+    return Fix(
+        id=fix_id,
+        issue=issue,
+        resolution=resolution,
+        error_excerpt=error_excerpt,
+        tags=tags,
+        notes=notes,
+        created_at=created_at or "",
+        updated_at=updated_at or "",
+        author=author,
+        author_email=author_email,
+    )
+
+
+def _extract_metadata(content: str, field: str) -> Optional[str]:
+    """Extract **Field:** value from content."""
+    pattern = rf"\*\*{re.escape(field)}:\*\*\s*(.+?)(?:\n|$)"
+    match = re.search(pattern, content)
+    if match:
+        return match.group(1).strip()
+    return None
+
+
+def _extract_tags(content: str) -> Optional[str]:
+    """Extract **Tags:** `value` from content."""
+    pattern = r"\*\*Tags:\*\*\s*`([^`]+)`"
+    match = re.search(pattern, content)
+    if match:
+        return match.group(1).strip()
+    return None
+
+
+def _extract_section(content: str, section_name: str) -> Optional[str]:
+    """Extract content under ## SectionName header."""
+    pattern = rf"##\s+{re.escape(section_name)}\s*\n\n?(.*?)(?=\n##\s|\n\*\*|\Z)"
+    match = re.search(pattern, content, re.DOTALL)
+    if match:
+        text = match.group(1).strip()
+        if text.startswith("```"):
+            return None
+        return text if text else None
+    return None
+
+
+def _extract_code_block(content: str, section_name: str) -> Optional[str]:
+    """Extract code block content from a section."""
+    pattern = rf"##\s+{re.escape(section_name)}\s*\n\n?```[^\n]*\n(.*?)```"
+    match = re.search(pattern, content, re.DOTALL)
+    if match:
+        return match.group(1).strip()
+    return None
+
+
+def parse_markdown_file(file_path: str) -> Fix:
+    """Parse a markdown file and return a Fix object."""
+    from pathlib import Path
+
+    path = Path(file_path)
+    if not path.exists():
+        raise MarkdownParseError(f"File not found: {file_path}")
+
+    fix_id = path.stem
+
+    with open(path, "r") as f:
+        content = f.read()
+
+    return markdown_to_fix(content, fix_id)

fixdoc/models.py

@@ -0,0 +1,83 @@
+"""Fix data model for fixdoc."""
+
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from typing import Optional
+import uuid
+
+
+def _now_iso() -> str:
+    """Get current UTC time as ISO string."""
+    return datetime.now(timezone.utc).isoformat()
+
+
+@dataclass
+class Fix:
+    """
+    Represents a fix.
+
+    Required fields: issue, resolution
+    Optional fields: error_excerpt, tags, notes, author, author_email
+    Auto-generated: id, created_at, updated_at
+    """
+
+    issue: str
+    resolution: str
+    error_excerpt: Optional[str] = None
+    tags: Optional[str] = None
+    notes: Optional[str] = None
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    created_at: str = field(default_factory=_now_iso)
+    updated_at: str = field(default_factory=_now_iso)
+    author: Optional[str] = None
+    author_email: Optional[str] = None
+    is_private: bool = False
+
+    def to_dict(self) -> dict:
+        """Convert fix to dictionary for JSON serialization."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Fix":
+        """Create a Fix instance from a dictionary."""
+        return cls(
+            id=data.get("id", str(uuid.uuid4())),
+            issue=data["issue"],
+            resolution=data["resolution"],
+            error_excerpt=data.get("error_excerpt"),
+            tags=data.get("tags"),
+            notes=data.get("notes"),
+            created_at=data.get("created_at", _now_iso()),
+            updated_at=data.get("updated_at", _now_iso()),
+            author=data.get("author"),
+            author_email=data.get("author_email"),
+            is_private=data.get("is_private", False),
+        )
+
+    def summary(self) -> str:
+        """Return a one-line summary for list displays."""
+        short_id = self.id[:8]
+        tags_str = f" [{self.tags}]" if self.tags else ""
+        issue_preview = self.issue[:40] + "..." if len(self.issue) > 40 else self.issue
+        return f"{short_id}{tags_str} - {issue_preview}"
+
+    def matches(self, query: str) -> bool:
+        """Check if this fix matches a search query (case-insensitive)."""
+        query_lower = query.lower()
+        searchable = " ".join(
+            filter(
+                None,
+                [self.issue, self.resolution, self.error_excerpt, self.tags, self.notes],
+            )
+        ).lower()
+        return query_lower in searchable
+
+    def matches_resource_type(self, resource_type: str) -> bool:
+        """Check if this fix is tagged with a specific resource type."""
+        if not self.tags:
+            return False
+        return resource_type.lower() in self.tags.lower()
+
+    def touch(self) -> None:
+        """Update the updated_at timestamp."""
+        self.updated_at = _now_iso()

fixdoc/parsers/__init__.py

@@ -0,0 +1,24 @@
+"""
+Multi-cloud and multi-tool error parsers for FixDoc.
+
+This module provides unified parsing for:
+- Terraform errors (AWS, Azure, GCP)
+- Kubernetes errors (kubectl, Helm)
+"""
+
+from .base import ParsedError, ErrorParser
+from .terraform import TerraformParser, TerraformError
+from .kubernetes import KubernetesParser, KubernetesError
+from .router import detect_and_parse, detect_error_source, ErrorSource
+
+__all__ = [
+    "ParsedError",
+    "ErrorParser",
+    "TerraformParser",
+    "TerraformError",
+    "KubernetesParser",
+    "KubernetesError",
+    "detect_and_parse",
+    "detect_error_source",
+    "ErrorSource",
+]

fixdoc/parsers/base.py

@@ -0,0 +1,131 @@
+"""Base classes and interfaces for error parsers."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+
+class CloudProvider(Enum):
+    """Cloud provider enumeration."""
+    AWS = "aws"
+    AZURE = "azure"
+    GCP = "gcp"
+    UNKNOWN = "unknown"
+
+
+class ErrorSeverity(Enum):
+    """Error severity levels."""
+    CRITICAL = "critical"
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+
+
+@dataclass
+class ParsedError:
+    """
+    Base class for all parsed errors.
+
+    This provides a unified interface for errors from different sources
+    (Terraform, Kubernetes, Ansible, etc.)
+    """
+
+    # Core error information
+    error_type: str  # e.g., "terraform", "kubectl", "helm"
+    error_message: str
+    raw_output: str
+
+    # Resource identification
+    resource_type: Optional[str] = None  # e.g., "aws_s3_bucket", "Deployment"
+    resource_name: Optional[str] = None
+    resource_address: Optional[str] = None  # Full address like "module.app.aws_s3_bucket.main"
+
+    # Location information
+    file: Optional[str] = None
+    line: Optional[int] = None
+    namespace: Optional[str] = None  # For K8s resources
+
+    # Error classification
+    error_code: Optional[str] = None  # e.g., "BucketAlreadyExists", "ImagePullBackOff"
+    cloud_provider: CloudProvider = CloudProvider.UNKNOWN
+    severity: ErrorSeverity = ErrorSeverity.ERROR
+
+    # Additional context
+    suggestions: list[str] = field(default_factory=list)
+    related_resources: list[str] = field(default_factory=list)
+    tags: list[str] = field(default_factory=list)
+
+    def short_error(self, max_length: int = 100) -> str:
+        """Return a shortened error description."""
+        if self.error_code:
+            prefix = f"{self.error_code}: "
+            remaining = max_length - len(prefix)
+            return f"{prefix}{self.error_message[:remaining]}"
+        return self.error_message[:max_length]
+
+    def generate_tags(self) -> str:
+        """Generate comma-separated tags for this error."""
+        tags = list(self.tags)
+
+        if self.resource_type:
+            tags.append(self.resource_type)
+
+        if self.cloud_provider != CloudProvider.UNKNOWN:
+            tags.append(self.cloud_provider.value)
+
+        if self.error_code:
+            tags.append(self.error_code)
+
+        if self.error_type:
+            tags.append(self.error_type)
+
+        # Deduplicate while preserving order
+        seen = set()
+        unique_tags = []
+        for tag in tags:
+            if tag.lower() not in seen:
+                seen.add(tag.lower())
+                unique_tags.append(tag)
+
+        return ",".join(unique_tags)
+
+    def to_issue_string(self) -> str:
+        """Generate an issue string for Fix creation."""
+        parts = []
+
+        if self.resource_address:
+            parts.append(self.resource_address)
+        elif self.resource_type and self.resource_name:
+            parts.append(f"{self.resource_type}/{self.resource_name}")
+        elif self.resource_type:
+            parts.append(self.resource_type)
+
+        parts.append(self.short_error())
+
+        return ": ".join(parts)
+
+
+class ErrorParser(ABC):
+    """Abstract base class for error parsers."""
+
+    @abstractmethod
+    def can_parse(self, text: str) -> bool:
+        """Check if this parser can handle the given text."""
+        pass
+
+    @abstractmethod
+    def parse(self, text: str) -> list[ParsedError]:
+        """Parse the text and return a list of errors."""
+        pass
+
+    @abstractmethod
+    def parse_single(self, text: str) -> Optional[ParsedError]:
+        """Parse a single error block."""
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the name of this parser."""
+        pass