fixdoc 0.0.1__py3-none-any.whl

fixdoc/storage.py

@@ -0,0 +1,146 @@
+"""Storage management for fixdoc."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+from .models import Fix
+from .formatter import fix_to_markdown
+
+
+class FixRepository:
+    """
+    Manages the local fix database and markdown files.
+
+    Storage structure:
+        ~/.fixdoc/
+            fixes.json      # JSON database
+            docs/           # Generated markdown files
+    """
+
+    DEFAULT_PATH = Path.home() / ".fixdoc"
+
+    def __init__(self, base_path: Optional[Path] = None):
+        self.base_path = base_path or self.DEFAULT_PATH
+        self.db_path = self.base_path / "fixes.json"
+        self.docs_path = self.base_path / "docs"
+        self._ensure_paths()
+
+    def _ensure_paths(self) -> None:
+        """Create necessary directories if they don't exist."""
+        self.base_path.mkdir(parents=True, exist_ok=True)
+        self.docs_path.mkdir(parents=True, exist_ok=True)
+        if not self.db_path.exists():
+            self._write_db([])
+
+    def _read_db(self) -> list[dict]:
+        """Read the JSON database."""
+        try:
+            with open(self.db_path, "r") as f:
+                # print('--------------',json.load(f))
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return []
+
+    def _write_db(self, data: list[dict]) -> None:
+        """Write to the JSON database."""
+        with open(self.db_path, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def _write_markdown(self, fix: Fix) -> Path:
+        """Generate markdown file for a fix."""
+        md_path = self.docs_path / f"{fix.id}.md"
+        with open(md_path, "w") as f:
+            f.write(fix_to_markdown(fix))
+        return md_path
+
+    def save(self, fix: Fix) -> Fix:
+        """Save a fix to the database and generate markdown."""
+        fixes = self._read_db()        
+
+        existing_idx = next(
+            (i for i, f in enumerate(fixes) if f.get("id") == fix.id), None
+        )
+
+        if existing_idx is not None:
+            fixes[existing_idx] = fix.to_dict()
+        else:
+            fixes.append(fix.to_dict())
+
+        self._write_db(fixes)
+        self._write_markdown(fix)
+        return fix
+
+    def get(self, fix_id: str) -> Optional[Fix]:
+        """Retrieve a fix by ID """
+        fixes = self._read_db()
+        fix_id_lower = fix_id.lower()
+
+        for f in fixes:
+            if f["id"].lower().startswith(fix_id_lower):
+                return Fix.from_dict(f)
+        return None
+
+    def list_all(self) -> list[Fix]:
+        """Return all fixes in the database."""
+        return [Fix.from_dict(f) for f in self._read_db()]
+
+    def search(self, query: str) -> list[Fix]:
+        """Search fixes by query string (case-insensitive)."""
+        return [f for f in self.list_all() if f.matches(query)]
+
+    def find_by_resource_type(self, resource_type: str) -> list[Fix]:
+        """Find all fixes tagged with a specific resource type."""
+        return [f for f in self.list_all() if f.matches_resource_type(resource_type)]
+
+    def delete(self, fix_id: str) -> bool:
+        """Delete a fix by ID. Returns True if deleted."""
+        fixes = self._read_db()
+        fix_id_lower = fix_id.lower()
+
+        for i, f in enumerate(fixes):
+            if f["id"].lower().startswith(fix_id_lower):
+                deleted_fix = fixes.pop(i)
+                self._write_db(fixes)
+
+                md_path = self.docs_path / f"{deleted_fix['id']}.md"
+                if md_path.exists():
+                    md_path.unlink()
+                return True
+        return False
+
+    def count(self) -> int:
+        """Return the number of fixes in the database."""
+        return len(self._read_db())
+
+    def purge(self) -> bool:
+        """Delete a fix by ID. Returns True if deleted."""
+        fixes = self._read_db()
+
+        for i, f in enumerate(fixes):
+            deleted_fix = fixes.pop(i)
+            self._write_db(fixes)
+
+            md_path = self.docs_path / f"{deleted_fix['id']}.md"
+            if md_path.exists():
+                md_path.unlink()
+            return True
+        return False
+
+    def get_by_full_id(self, fix_id: str) -> Optional[Fix]:
+        """Get fix by exact ID match (for sync operations)."""
+        fixes = self._read_db()
+        for f in fixes:
+            if f["id"] == fix_id:
+                return Fix.from_dict(f)
+        return None
+
+    def list_markdown_files(self) -> list[Path]:
+        """List all markdown files in docs directory."""
+        if not self.docs_path.exists():
+            return []
+        return list(self.docs_path.glob("*.md"))
+
+    def get_fix_ids(self) -> set[str]:
+        """Get set of all fix IDs."""
+        return {f["id"] for f in self._read_db()}

fixdoc/sync_engine.py

@@ -0,0 +1,330 @@
+"""Core synchronization logic for fixdoc sync."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import List, Optional
+
+from .config import ConfigManager
+from .formatter import fix_to_markdown
+from .git import GitOperations, GitError, SyncStatus
+from .markdown_parser import markdown_to_fix, MarkdownParseError
+from .models import Fix
+from .storage import FixRepository
+
+
+class ConflictType(Enum):
+    """Types of sync conflicts."""
+
+    BOTH_MODIFIED = "both_modified"
+    LOCAL_DELETED_REMOTE_MODIFIED = "local_deleted"
+    REMOTE_DELETED_LOCAL_MODIFIED = "remote_deleted"
+
+
+@dataclass
+class SyncConflict:
+    """Represents a conflict during sync."""
+
+    fix_id: str
+    conflict_type: ConflictType
+    local_fix: Optional[Fix] = None
+    remote_fix: Optional[Fix] = None
+
+
+@dataclass
+class SyncResult:
+    """Result of a sync operation."""
+
+    success: bool
+    pushed_fixes: List[str] = field(default_factory=list)
+    pulled_fixes: List[str] = field(default_factory=list)
+    conflicts: List[SyncConflict] = field(default_factory=list)
+    error_message: Optional[str] = None
+
+
+class SyncEngine:
+    """Handles the core sync logic."""
+
+    def __init__(
+        self,
+        repo: FixRepository,
+        git: GitOperations,
+        config_manager: ConfigManager,
+    ):
+        self.repo = repo
+        self.git = git
+        self.config_manager = config_manager
+
+    def prepare_push(self, push_all: bool = False) -> List[Fix]:
+        """
+        Identify fixes that need to be pushed.
+
+        By default, only returns fixes that are new or have been modified
+        since the last push. Use push_all=True to push all non-private fixes.
+        """
+        config = self.config_manager.load()
+        all_fixes = self.repo.list_all()
+
+        pushable = []
+        for fix in all_fixes:
+            if fix.is_private:
+                continue
+            if fix.id in config.private_fixes:
+                continue
+            pushable.append(fix)
+
+        if push_all:
+            return pushable
+
+        # Filter to only new or changed fixes by comparing generated
+        # markdown against what's already committed in HEAD.
+        changed = []
+        for fix in pushable:
+            current_md = fix_to_markdown(fix)
+            committed_md = self.git.get_file_content_at_ref(
+                f"docs/{fix.id}.md", "HEAD"
+            )
+            if committed_md is None or committed_md != current_md:
+                changed.append(fix)
+
+        return changed
+
+    def execute_push(self, fixes: List[Fix], commit_message: Optional[str] = None) -> SyncResult:
+        """
+        Push fixes to remote:
+        1. Regenerate markdown files for fixes
+        2. Git add changed files
+        3. Git commit with message and author info
+        4. Git push to remote
+        """
+        config = self.config_manager.load()
+
+        if not config.sync.remote_url:
+            return SyncResult(
+                success=False,
+                error_message="Sync not configured. Run 'fixdoc sync init' first.",
+            )
+
+        if not fixes:
+            return SyncResult(
+                success=True,
+                pushed_fixes=[],
+                error_message="No fixes to push.",
+            )
+
+        try:
+            docs_path = self.repo.docs_path
+            pushed_ids = []
+
+            for fix in fixes:
+                if config.user.name and not fix.author:
+                    fix.author = config.user.name
+                    fix.author_email = config.user.email
+                    self.repo.save(fix)
+
+                md_path = docs_path / f"{fix.id}.md"
+                with open(md_path, "w") as f:
+                    f.write(fix_to_markdown(fix))
+                pushed_ids.append(fix.id)
+
+            self.git.add("docs/")
+
+            if not self.git.has_uncommitted_changes():
+                return SyncResult(
+                    success=True,
+                    pushed_fixes=[],
+                    error_message="No changes to push.",
+                )
+
+            if not commit_message:
+                if len(fixes) == 1:
+                    commit_message = f"[fixdoc] Add fix: {fixes[0].id[:8]}"
+                else:
+                    commit_message = f"[fixdoc] Add/update {len(fixes)} fixes"
+
+            author = None
+            if config.user.name and config.user.email:
+                author = f"{config.user.name} <{config.user.email}>"
+
+            self.git.commit(commit_message, author=author)
+            self.git.push(branch=config.sync.branch)
+
+            return SyncResult(success=True, pushed_fixes=pushed_ids)
+
+        except GitError as e:
+            return SyncResult(success=False, error_message=str(e))
+
+    def execute_pull(self, force: bool = False) -> SyncResult:
+        """
+        Pull fixes from remote:
+        1. Git fetch
+        2. Detect conflicts
+        3. If no conflicts or force=True: git pull and update local DB
+        4. If conflicts: return conflicts for user resolution
+        """
+        config = self.config_manager.load()
+
+        if not config.sync.remote_url:
+            return SyncResult(
+                success=False,
+                error_message="Sync not configured. Run 'fixdoc sync init' first.",
+            )
+
+        try:
+            if force and self.git.has_uncommitted_changes():
+                self.git.stash()
+
+            had_conflicts, conflict_files = self.git.pull(branch=config.sync.branch)
+
+            if had_conflicts and not force:
+                conflicts = self._build_conflicts_from_files(conflict_files)
+                self.git.reset_hard("HEAD")
+                return SyncResult(success=False, conflicts=conflicts)
+
+            pulled_fixes = self.rebuild_json_from_markdown()
+
+            if force:
+                self.git.stash_pop()
+
+            return SyncResult(success=True, pulled_fixes=pulled_fixes)
+
+        except GitError as e:
+            return SyncResult(success=False, error_message=str(e))
+
+    def _build_conflicts_from_files(self, conflict_files: List[str]) -> List[SyncConflict]:
+        """Build conflict objects from conflicted file paths."""
+        conflicts = []
+        for filepath in conflict_files:
+            if filepath.startswith("docs/") and filepath.endswith(".md"):
+                fix_id = Path(filepath).stem
+                local_fix = self.repo.get(fix_id)
+                conflicts.append(
+                    SyncConflict(
+                        fix_id=fix_id,
+                        conflict_type=ConflictType.BOTH_MODIFIED,
+                        local_fix=local_fix,
+                        remote_fix=None,
+                    )
+                )
+        return conflicts
+
+    def rebuild_json_from_markdown(self) -> List[str]:
+        """
+        Rebuild fixes.json from markdown files.
+        Markdown is source of truth for sync.
+        Returns list of fix IDs that were updated/added.
+        """
+        docs_path = self.repo.docs_path
+        updated_ids = []
+
+        if not docs_path.exists():
+            return updated_ids
+
+        existing_fixes = {fix.id: fix for fix in self.repo.list_all()}
+
+        for md_file in docs_path.glob("*.md"):
+            fix_id = md_file.stem
+            try:
+                with open(md_file, "r") as f:
+                    content = f.read()
+                parsed_fix = markdown_to_fix(content, fix_id)
+
+                if fix_id in existing_fixes:
+                    existing = existing_fixes[fix_id]
+                    if parsed_fix.is_private or existing.is_private:
+                        parsed_fix.is_private = existing.is_private
+
+                self.repo.save(parsed_fix)
+                updated_ids.append(fix_id)
+            except MarkdownParseError:
+                continue
+
+        return updated_ids
+
+    def resolve_conflict(
+        self, conflict: SyncConflict, resolution: str
+    ) -> Optional[Fix]:
+        """
+        Resolve a conflict based on user choice:
+        - 'local': Keep local version
+        - 'remote': Accept remote version
+        - 'merge': Combine both (add both to notes)
+        """
+        if resolution == "local":
+            return conflict.local_fix
+
+        elif resolution == "remote":
+            return conflict.remote_fix
+
+        elif resolution == "merge" and conflict.local_fix and conflict.remote_fix:
+            merged = Fix(
+                id=conflict.fix_id,
+                issue=conflict.remote_fix.issue,
+                resolution=conflict.remote_fix.resolution,
+                error_excerpt=conflict.remote_fix.error_excerpt or conflict.local_fix.error_excerpt,
+                tags=self._merge_tags(conflict.local_fix.tags, conflict.remote_fix.tags),
+                notes=self._merge_notes(conflict.local_fix, conflict.remote_fix),
+                created_at=conflict.local_fix.created_at,
+                updated_at=conflict.remote_fix.updated_at,
+                author=conflict.remote_fix.author or conflict.local_fix.author,
+                author_email=conflict.remote_fix.author_email or conflict.local_fix.author_email,
+            )
+            return merged
+
+        return None
+
+    def _merge_tags(self, local_tags: Optional[str], remote_tags: Optional[str]) -> Optional[str]:
+        """Merge two tag strings, removing duplicates."""
+        if not local_tags and not remote_tags:
+            return None
+
+        local_set = set(t.strip() for t in (local_tags or "").split(",") if t.strip())
+        remote_set = set(t.strip() for t in (remote_tags or "").split(",") if t.strip())
+        merged = local_set | remote_set
+
+        return ",".join(sorted(merged)) if merged else None
+
+    def _merge_notes(self, local_fix: Fix, remote_fix: Fix) -> Optional[str]:
+        """Merge notes from both versions."""
+        parts = []
+
+        if local_fix.notes:
+            parts.append(f"### Local Notes:\n{local_fix.notes}")
+
+        if remote_fix.notes:
+            parts.append(f"### Remote Notes:\n{remote_fix.notes}")
+
+        if local_fix.resolution != remote_fix.resolution:
+            parts.append(f"### Local Resolution (merged):\n{local_fix.resolution}")
+
+        if parts:
+            return "\n\n".join(parts)
+        return None
+
+    def get_sync_status(self) -> dict:
+        """Get current sync status information."""
+        config = self.config_manager.load()
+
+        if not config.sync.remote_url:
+            return {
+                "configured": False,
+                "message": "Sync not configured.",
+            }
+
+        git_status = self.git.get_status(branch=config.sync.branch)
+        all_fixes = self.repo.list_all()
+        pushable = self.prepare_push(push_all=False)
+        private_count = len([f for f in all_fixes if f.is_private or f.id in config.private_fixes])
+
+        return {
+            "configured": True,
+            "remote_url": config.sync.remote_url,
+            "branch": config.sync.branch,
+            "status": git_status.status.value,
+            "commits_ahead": git_status.commits_ahead,
+            "commits_behind": git_status.commits_behind,
+            "local_changes": git_status.local_changes,
+            "pushable_fixes": len(pushable),
+            "private_fixes": private_count,
+            "total_fixes": len(all_fixes),
+        }

fixdoc/terraform_parser.py

@@ -0,0 +1,135 @@
+## This file will parse terraform plan/apply and extract the relevant errors using regular expression matching
+
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class TerraformError:
+    ##Parsed error object created from terraform output
+
+    resource_type: str
+    resource_name: str
+    resource_address: str
+    error_code: Optional[str]
+    error_message: str
+    file: Optional[str]
+    line: Optional[int]
+    raw_output: str
+
+    def short_error(self) -> str:
+        """Short error description for display."""
+        if self.error_code:
+            return f"{self.error_code}: {self.error_message[:100]}"
+        return self.error_message[:100]
+
+
+def parse_terraform_error(output: str) -> Optional[TerraformError]:
+    """Parse a terraform error block."""
+
+    # Find error block
+    error_match = re.search(
+        r'│?\s*Error:\s*(.+?)(?=\n│?\s*\n|\n\n|$)', output, re.DOTALL
+    )
+    if not error_match:
+        error_match = re.search(r'Error:\s*(.+?)(?=\n\n|$)', output, re.DOTALL)
+    if not error_match:
+        return None
+
+    error_block = error_match.group(0)
+
+    # Extract resource address with regex
+    resource_match = re.search(
+        r'with\s+((?:module\.[^,\s]+\.)?([a-z_]+)\.([a-z0-9_-]+))',
+        output,
+        re.IGNORECASE,
+    )
+
+    if resource_match:
+        resource_address = resource_match.group(1)
+        resource_type = resource_match.group(2)
+        resource_name = resource_match.group(3)
+    else:
+        resource_type, resource_name, resource_address = "unknown", "unknown", "unknown"
+
+    # Extract file and line
+    file_match = re.search(r'on\s+([^\s]+\.tf)\s+line\s+(\d+)', output)
+    file = file_match.group(1) if file_match else None
+    line = int(file_match.group(2)) if file_match else None
+
+    # Extract error code
+    error_code = _extract_error_code(output)
+
+    # Extract error message
+    error_message = _extract_error_message(output, error_block)
+
+    return TerraformError(
+        resource_type=resource_type,
+        resource_name=resource_name,
+        resource_address=resource_address,
+        error_code=error_code,
+        error_message=error_message,
+        file=file,
+        line=line,
+        raw_output=output,
+    )
+
+
+def _extract_error_code(output: str) -> Optional[str]:
+    ##Extract error code from terraform 
+    code_match = re.search(r'Code:\s*["\']?([A-Za-z0-9_]+)["\']?', output)
+    if code_match:
+        return code_match.group(1)
+
+    status_match = re.search(r'Status:\s*(\d+\s*[A-Za-z]+)', output)
+    if status_match:
+        return status_match.group(1)
+
+    return None
+
+
+def _extract_error_message(output: str, error_block: str) -> str:
+    ##Extract error code from terraform 
+    msg_match = re.search(
+        r'Message:\s*["\']?(.+?)["\']?(?=\n│|\n\n|$)', output, re.DOTALL
+    )
+    if msg_match:
+        message = msg_match.group(1).strip()
+    else:
+        first_line = error_block.split('\n')[0]
+        message = re.sub(r'^│?\s*Error:\s*', '', first_line).strip()
+
+    message = re.sub(r'\s+', ' ', message).strip()
+    return message[:500]
+
+
+def parse_terraform_output(output: str) -> list[TerraformError]:
+    ##Parse terraform output for all errors.
+    errors = []
+    parts = re.split(r'(?=│?\s*Error:)', output)
+
+    for part in parts:
+        if 'Error:' in part:
+            parsed = parse_terraform_error(part)
+            if parsed:
+                errors.append(parsed)
+
+    # resource addresses should be unique
+    seen = set()
+    unique = []
+    for e in errors:
+        if e.resource_address not in seen:
+            seen.add(e.resource_address)
+            unique.append(e)
+
+    return unique
+
+
+def is_terraform_output(text: str) -> bool:
+    indicators = [
+        'Error:', 'azurerm_', 'aws_', 'google_',
+        '.tf line', 'with module.', 'Plan:', 'Apply',
+    ]
+    text_lower = text.lower()
+    return any(ind.lower() in text_lower for ind in indicators)