ghostfix 0.1.0__py3-none-any.whl

ghostfix/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

ghostfix/ai/__init__.py

@@ -0,0 +1,4 @@
+from .router import AIRouter
+from .base import BaseProvider
+
+__all__ = ["AIRouter", "BaseProvider"]

ghostfix/ai/base.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+
+
+class BaseProvider(ABC):
+    @abstractmethod
+    def complete(self, system: str, user: str) -> str | None:
+        """Send prompt, return raw text response."""
+        ...

ghostfix/ai/claude_provider.py

@@ -0,0 +1,34 @@
+import httpx
+from ghostfix.ai.base import BaseProvider
+
+CLAUDE_URL = "https://api.anthropic.com/v1/messages"
+
+
+class ClaudeProvider(BaseProvider):
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    def complete(self, system: str, user: str) -> str | None:
+        headers = {
+            "x-api-key": self.api_key,
+            "anthropic-version": "2023-06-01",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": "claude-opus-4-6",
+            "max_tokens": 2000,
+            "system": system,
+            "messages": [
+                {"role": "user", "content": user},
+            ],
+        }
+        try:
+            with httpx.Client(timeout=60) as client:
+                resp = client.post(CLAUDE_URL, json=payload, headers=headers)
+                resp.raise_for_status()
+                data = resp.json()
+                return data["content"][0]["text"]
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(f"Claude API error {e.response.status_code}: {e.response.text}")
+        except Exception as e:
+            raise RuntimeError(f"Claude request failed: {e}")

ghostfix/ai/custom_provider.py

@@ -0,0 +1,93 @@
+"""
+CustomProvider
+Calls any OpenAI-compatible endpoint (Ollama, LM Studio, vLLM,
+your own server, etc.) defined in ghostfix.config.py.
+
+Expected request format (OpenAI-compatible):
+  POST /v1/chat/completions  OR  /api/chat (Ollama)
+  { "model": "...", "messages": [...] }
+
+Expected response (either format):
+  OpenAI:  { "choices": [{ "message": { "content": "..." } }] }
+  Ollama:  { "message": { "content": "..." } }
+"""
+import httpx
+from ghostfix.ai.base import BaseProvider
+
+
+class CustomProvider(BaseProvider):
+    def __init__(self, model_cfg: dict):
+        self.endpoint = model_cfg["endpoint"].rstrip("/")
+        self.model_name = model_cfg.get("model_name", "")
+        self.api_key = model_cfg.get("api_key", "")
+        self.extra_headers = model_cfg.get("headers", {})
+        self.timeout = model_cfg.get("timeout_seconds", 120)
+
+        # Auto-detect Ollama vs OpenAI-compatible
+        self._is_ollama = "ollama" in self.endpoint or "/api/chat" in self.endpoint
+
+    def complete(self, system: str, user: str) -> str | None:
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        headers.update(self.extra_headers)
+
+        if self._is_ollama:
+            return self._call_ollama(headers, system, user)
+        else:
+            return self._call_openai_compat(headers, system, user)
+
+    def _call_ollama(self, headers: dict, system: str, user: str) -> str | None:
+        """Ollama /api/chat format."""
+        payload = {
+            "model": self.model_name,
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            "stream": False,
+            "options": {"temperature": 0.2},
+        }
+        url = self.endpoint
+        if not url.endswith("/api/chat"):
+            url = url.rstrip("/") + "/api/chat"
+
+        try:
+            with httpx.Client(timeout=self.timeout) as client:
+                resp = client.post(url, json=payload, headers=headers)
+                resp.raise_for_status()
+                data = resp.json()
+                # Ollama returns { "message": { "content": "..." } }
+                return data.get("message", {}).get("content")
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(f"Custom model error {e.response.status_code}: {e.response.text}")
+        except Exception as e:
+            raise RuntimeError(f"Custom model request failed: {e}")
+
+    def _call_openai_compat(self, headers: dict, system: str, user: str) -> str | None:
+        """OpenAI-compatible /v1/chat/completions format."""
+        payload = {
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            "temperature": 0.2,
+            "max_tokens": 2000,
+        }
+        if self.model_name:
+            payload["model"] = self.model_name
+
+        url = self.endpoint
+        if not url.endswith("/chat/completions"):
+            url = url.rstrip("/") + "/v1/chat/completions"
+
+        try:
+            with httpx.Client(timeout=self.timeout) as client:
+                resp = client.post(url, json=payload, headers=headers)
+                resp.raise_for_status()
+                data = resp.json()
+                return data["choices"][0]["message"]["content"]
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(f"Custom model error {e.response.status_code}: {e.response.text}")
+        except Exception as e:
+            raise RuntimeError(f"Custom model request failed: {e}")

ghostfix/ai/gemini_provider.py

@@ -0,0 +1,33 @@
+import httpx
+from ghostfix.ai.base import BaseProvider
+
+
+class GeminiProvider(BaseProvider):
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.url = (
+            f"https://generativelanguage.googleapis.com/v1beta/models/"
+            f"gemini-2.5-flash:generateContent?key={api_key}"
+        )
+
+    def complete(self, system: str, user: str) -> str | None:
+        payload = {
+            "system_instruction": {"parts": [{"text": system}]},
+            "contents": [
+                {"role": "user", "parts": [{"text": user}]}
+            ],
+            "generationConfig": {
+                "temperature": 0.2,
+                "maxOutputTokens": 2000,
+            },
+        }
+        try:
+            with httpx.Client(timeout=60) as client:
+                resp = client.post(self.url, json=payload)
+                resp.raise_for_status()
+                data = resp.json()
+                return data["candidates"][0]["content"]["parts"][0]["text"]
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(f"Gemini API error {e.response.status_code}: {e.response.text}")
+        except Exception as e:
+            raise RuntimeError(f"Gemini request failed: {e}")

ghostfix/ai/openai_provider.py

@@ -0,0 +1,34 @@
+import httpx
+from ghostfix.ai.base import BaseProvider
+
+OPENAI_URL = "https://api.openai.com/v1/chat/completions"
+
+
+class OpenAIProvider(BaseProvider):
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    def complete(self, system: str, user: str) -> str | None:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": "gpt-4o",
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            "temperature": 0.2,
+            "max_tokens": 2000,
+        }
+        try:
+            with httpx.Client(timeout=60) as client:
+                resp = client.post(OPENAI_URL, json=payload, headers=headers)
+                resp.raise_for_status()
+                data = resp.json()
+                return data["choices"][0]["message"]["content"]
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(f"OpenAI API error {e.response.status_code}: {e.response.text}")
+        except Exception as e:
+            raise RuntimeError(f"OpenAI request failed: {e}")

ghostfix/ai/router.py

@@ -0,0 +1,127 @@
+"""
+AIRouter
+Selects and calls the correct AI provider based on config.
+Builds the prompt and parses the JSON response.
+"""
+import json
+import re
+
+from ghostfix.core.error_parser import ParsedError
+from ghostfix.core.context_builder import CodeContext
+
+
+SYSTEM_PROMPT = """\
+You are GhostFix, an expert debugging assistant embedded in a developer's terminal.
+
+Analyze the error and code context provided. Respond ONLY with a valid JSON object — no markdown, no preamble, no explanation outside the JSON.
+
+JSON schema:
+{
+  "root_cause": "<2-3 sentence clear explanation of WHY the error happened>",
+  "explanation": "<deeper technical explanation>",
+  "fix_suggestion": "<what the developer should do to fix it>",
+  "patch": "<unified diff patch string, or empty string if no patch needed>",
+  "confidence": <float 0.0-1.0>,
+  "related_files": ["<other files that may need changes>"]
+}
+
+Patch format rules:
+- Use standard unified diff format (--- a/file, +++ b/file, @@ hunks)
+- Include enough context lines (3) around changes
+- Only patch what is necessary
+- If the fix requires running a command (e.g. migrations), set patch to "" and explain in fix_suggestion
+"""
+
+
+def _build_user_prompt(parsed: ParsedError, context: CodeContext) -> str:
+    parts = [
+        f"LANGUAGE: {parsed.language}",
+        f"ERROR TYPE: {parsed.error_type}",
+        f"ERROR MESSAGE: {parsed.error_message}",
+        "",
+        "=== FULL ERROR OUTPUT ===",
+        parsed.raw[:3000],
+        "",
+    ]
+
+    if context.primary_file and context.primary_snippet:
+        parts += [
+            f"=== PRIMARY FILE: {context.primary_file} ===",
+            context.primary_snippet,
+            "",
+        ]
+
+    for rf in context.related_files:
+        parts += [
+            f"=== RELATED FILE: {rf['path']} (around line {rf['line']}) ===",
+            rf["snippet"],
+            "",
+        ]
+
+    if context.project_tree:
+        parts += [
+            "=== PROJECT STRUCTURE ===",
+            context.project_tree[:1500],
+            "",
+        ]
+
+    return "\n".join(parts)
+
+
+def _parse_response(text: str) -> dict | None:
+    """Extract JSON from AI response, handle markdown fences."""
+    text = text.strip()
+    # Strip ```json ... ``` fences
+    text = re.sub(r"^```(?:json)?\s*", "", text)
+    text = re.sub(r"\s*```$", "", text)
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        # Try to find JSON object in response
+        m = re.search(r'\{.*\}', text, re.DOTALL)
+        if m:
+            try:
+                return json.loads(m.group(0))
+            except Exception:
+                pass
+    return None
+
+
+class AIRouter:
+    def __init__(self, config: dict):
+        self.config = config
+        self._provider = None
+        self._init_provider()
+
+    def _init_provider(self):
+        model_cfg = self.config.get("model")
+        if model_cfg and model_cfg.get("type") == "custom":
+            from ghostfix.ai.custom_provider import CustomProvider
+            self._provider = CustomProvider(model_cfg)
+            return
+
+        provider_name = self.config.get("provider", "openai")
+        api_key = self.config.get("api_key", "")
+
+        if provider_name == "openai":
+            from ghostfix.ai.openai_provider import OpenAIProvider
+            self._provider = OpenAIProvider(api_key)
+        elif provider_name == "claude":
+            from ghostfix.ai.claude_provider import ClaudeProvider
+            self._provider = ClaudeProvider(api_key)
+        elif provider_name == "gemini":
+            from ghostfix.ai.gemini_provider import GeminiProvider
+            self._provider = GeminiProvider(api_key)
+        else:
+            raise ValueError(f"Unknown provider: {provider_name}")
+
+    def analyze(self, parsed: ParsedError, context: CodeContext) -> dict | None:
+        user_msg = _build_user_prompt(parsed, context)
+        raw = self._provider.complete(
+            system=SYSTEM_PROMPT,
+            user=user_msg,
+        )
+        if not raw:
+            return None
+        result = _parse_response(raw)
+        return result

ghostfix/cli.py

@@ -0,0 +1,181 @@
+"""
+GhostFix CLI — AI-powered terminal error watcher & auto-fixer
+"""
+import click
+import sys
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from ghostfix.config.manager import ConfigManager
+from ghostfix.core.watcher import ProcessWatcher
+from ghostfix.ui.renderer import Renderer
+
+console = Console()
+
+
+def print_banner():
+    banner = Text()
+    banner.append("👻 GhostFix", style="bold magenta")
+    banner.append(" v0.1.0", style="dim")
+    banner.append("  —  AI-powered error watcher & auto-fixer", style="italic cyan")
+    console.print(Panel(banner, border_style="magenta", padding=(0, 2)))
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def main(ctx):
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+@main.command()
+@click.argument("command")
+@click.option("--fix", is_flag=True, default=False, help="Auto-fix errors when detected")
+@click.option("--ai", is_flag=True, default=False, help="Use cloud AI provider (OpenAI/Claude/Gemini)")
+@click.option("--provider", type=click.Choice(["openai", "claude", "gemini"]), default=None, help="Force specific AI provider")
+@click.option("--auto", is_flag=True, default=False, help="Apply patches without confirmation")
+@click.option("--config", type=click.Path(), default=None, help="Path to ghostfix.config.py")
+@click.option("--verbose", "-v", is_flag=True, default=False, help="Show verbose output")
+def watch(command, fix, ai, provider, auto, config, verbose):
+    """Watch a command and auto-fix errors.
+
+    \b
+    Examples:
+      ghostfix watch "npm run server" --fix --ai
+      ghostfix watch "python manage.py runserver" --fix
+      ghostfix watch "flask run" --fix --ai --provider claude
+      ghostfix watch "go run main.go" --fix
+    """
+    print_banner()
+
+    # Load config
+    cfg_manager = ConfigManager(config_path=config)
+    cfg = cfg_manager.load()
+
+    # If --ai flag, ensure provider is configured
+    if ai:
+        cfg = cfg_manager.ensure_ai_provider(
+            cfg,
+            force_provider=provider,
+            prompt_each_run=True,
+            save=False,
+        )
+
+    elif not cfg.get("model"):
+        # No --ai and no config model → prompt user
+        console.print(
+            "\n[yellow]⚠  No AI provider configured.[/yellow]\n"
+            "Run with [bold]--ai[/bold] to use a cloud provider, or create a "
+            "[bold]ghostfix.config.py[/bold] for a custom/local model.\n"
+        )
+        sys.exit(1)
+
+    # Override auto_apply if --auto flag
+    if auto:
+        cfg.setdefault("fix", {})["auto_apply"] = True
+
+    renderer = Renderer(console=console, verbose=verbose)
+
+    watcher = ProcessWatcher(
+        command=command,
+        config=cfg,
+        fix_enabled=fix,
+        renderer=renderer,
+    )
+
+    try:
+        console.print(f"\n[bold green]▶  Watching:[/bold green] [cyan]{command}[/cyan]\n")
+        watcher.run()
+    except KeyboardInterrupt:
+        console.print("\n\n[dim]👻 GhostFix stopped.[/dim]\n")
+        sys.exit(0)
+
+
+@main.command()
+def setup():
+    """Interactive setup: configure AI provider and API key."""
+    print_banner()
+    cfg_manager = ConfigManager()
+    cfg = cfg_manager.load()
+    cfg_manager.ensure_ai_provider(cfg, force_provider=None)
+    console.print("\n[green]✅  Setup complete![/green]")
+
+
+@main.command()
+def config_show():
+    """Show current GhostFix configuration."""
+    print_banner()
+    cfg_manager = ConfigManager()
+    cfg = cfg_manager.load()
+    import json
+    # Mask API keys
+    display = dict(cfg)
+    if display.get("api_key"):
+        display["api_key"] = display["api_key"][:8] + "..." 
+    console.print_json(json.dumps(display, indent=2))
+
+
+@main.command()
+def init():
+    """Create a ghostfix.config.py in the current directory (for custom models)."""
+    target = Path.cwd() / "ghostfix.config.py"
+    if target.exists():
+        console.print("[yellow]ghostfix.config.py already exists.[/yellow]")
+        return
+
+    template = '''\
+# ghostfix.config.py
+# Place this file in your project root to use a custom/local model
+# without needing any cloud API key.
+
+GHOSTFIX_CONFIG = {
+    "model": {
+        "type": "custom",
+
+        # --- Ollama (local) example ---
+        "endpoint": "http://localhost:11434/api/chat",
+        "model_name": "codellama:13b",
+
+        # --- Your own server example ---
+        # "endpoint": "http://192.168.1.100:8000/v1/chat",
+        # "api_key": "optional-if-needed",
+        # "headers": {"X-Custom-Header": "value"},
+        #
+        # The endpoint must accept POST with JSON body:
+        # { "model": "...", "messages": [...] }
+        # and return { "message": { "content": "..." } }
+        # (OpenAI-compatible format)
+    },
+
+    "watch": {
+        "ignore": [
+            "node_modules", ".git", "dist", "__pycache__",
+            "venv", ".env", "migrations", ".mypy_cache",
+        ],
+        "max_file_size_kb": 500,
+        "context_lines": 60,
+    },
+
+    "fix": {
+        "auto_apply": False,       # True = no confirmation prompt
+        "create_backup": True,     # backup before patching
+        "restart_on_fix": True,    # restart command after fix
+        "max_retries": 3,          # retry limit for same error
+    },
+
+    "ui": {
+        "language": "english",     # "bangla" coming soon
+        "show_diff": True,
+        "color_theme": "dark",
+    },
+}
+'''
+    target.write_text(template)
+    console.print(f"[green]✅  Created:[/green] {target}")
+    console.print("[dim]Edit ghostfix.config.py to point to your local model endpoint.[/dim]")
+
+
+if __name__ == "__main__":
+    main()

ghostfix/config/__init__.py

@@ -0,0 +1,2 @@
+from .manager import ConfigManager
+__all__ = ["ConfigManager"]

ghostfix/config/manager.py

@@ -0,0 +1,159 @@
+"""
+Config Manager
+Handles:
+  - ~/.ghostfix/config.json  (global: AI provider + API key)
+  - ./ghostfix.config.py     (project-level: custom model, watch settings)
+"""
+import json
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+from rich.panel import Panel
+
+console = Console()
+
+GLOBAL_CONFIG_DIR = Path.home() / ".ghostfix"
+GLOBAL_CONFIG_FILE = GLOBAL_CONFIG_DIR / "config.json"
+
+PROVIDERS = {
+    "1": ("openai",  "OpenAI    (GPT-4o)"),
+    "2": ("claude",  "Claude    (Anthropic)"),
+    "3": ("gemini",  "Gemini    (Google)"),
+}
+
+
+class ConfigManager:
+    def __init__(self, config_path: str | None = None):
+        self.config_path = Path(config_path) if config_path else None
+
+    # ------------------------------------------------------------------ #
+    #  Load                                                                #
+    # ------------------------------------------------------------------ #
+    def load(self) -> dict:
+        cfg: dict = {}
+
+        # 1. Global config
+        if GLOBAL_CONFIG_FILE.exists():
+            try:
+                cfg.update(json.loads(GLOBAL_CONFIG_FILE.read_text()))
+            except Exception:
+                pass
+
+        # 2. Project-level ghostfix.config.py  (overrides global)
+        project_cfg = self._load_project_config()
+        if project_cfg:
+            self._merge(cfg, project_cfg)
+
+        return cfg
+
+    def _load_project_config(self) -> dict | None:
+        """Import ghostfix.config.py from project root (or --config path)."""
+        candidates = []
+        if self.config_path:
+            candidates.append(self.config_path)
+        candidates.append(Path.cwd() / "ghostfix.config.py")
+
+        for p in candidates:
+            if p.exists():
+                try:
+                    import importlib.util
+                    spec = importlib.util.spec_from_file_location("_ghostfix_cfg", p)
+                    mod = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(mod)
+                    raw = getattr(mod, "GHOSTFIX_CONFIG", None)
+                    if isinstance(raw, dict):
+                        console.print(f"[dim]📄 Loaded project config: {p}[/dim]")
+                        return raw
+                except Exception as e:
+                    console.print(f"[yellow]⚠  Could not load {p}: {e}[/yellow]")
+        return None
+
+    @staticmethod
+    def _merge(base: dict, override: dict):
+        for k, v in override.items():
+            if isinstance(v, dict) and isinstance(base.get(k), dict):
+                ConfigManager._merge(base[k], v)
+            else:
+                base[k] = v
+
+    # ------------------------------------------------------------------ #
+    #  Save                                                                #
+    # ------------------------------------------------------------------ #
+    def _save_global(self, cfg: dict):
+        GLOBAL_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        GLOBAL_CONFIG_FILE.write_text(json.dumps(cfg, indent=2))
+
+    # ------------------------------------------------------------------ #
+    #  Interactive AI setup                                                #
+    # ------------------------------------------------------------------ #
+    def ensure_ai_provider(
+        self,
+        cfg: dict,
+        force_provider: str | None = None,
+        *,
+        prompt_each_run: bool = False,
+        save: bool = True,
+    ) -> dict:
+        """Make sure an AI cloud provider + API key is configured."""
+        # Already have everything?
+        if cfg.get("provider") and cfg.get("api_key") and not force_provider and not prompt_each_run:
+            console.print(
+                f"[dim]🔑 Using saved provider: [bold]{cfg['provider']}[/bold][/dim]"
+            )
+            return cfg
+
+        # Choose provider
+        if force_provider:
+            provider = force_provider
+        else:
+            provider = self._prompt_provider()
+
+        # Ask for API key
+        existing_key = "" if prompt_each_run else cfg.get("api_key", "")
+        if existing_key:
+            mask = existing_key[:8] + "..."
+            use_saved = Confirm.ask(
+                f"\n[cyan]Use saved API key[/cyan] [dim]({mask})[/dim]?",
+                default=True,
+            )
+            if not use_saved:
+                existing_key = ""
+
+        if not existing_key:
+            key_label = {
+                "openai": "OpenAI API key (sk-...)",
+                "claude": "Anthropic API key (sk-ant-...)",
+                "gemini": "Google Gemini API key",
+            }.get(provider, "API key")
+            api_key = Prompt.ask(f"\n[cyan]Enter your {key_label}[/cyan]", password=True)
+            if not api_key.strip():
+                console.print("[red]No API key provided. Exiting.[/red]")
+                sys.exit(1)
+            existing_key = api_key.strip()
+
+        cfg["provider"] = provider
+        cfg["api_key"] = existing_key
+        if save:
+            self._save_global(cfg)
+            console.print(f"\n[green]✅  Provider saved:[/green] {provider}\n")
+        else:
+            console.print(f"\n[green]✅  Provider selected for this run:[/green] {provider}\n")
+        return cfg
+
+    def _prompt_provider(self) -> str:
+        console.print(
+            Panel(
+                "\n".join(f"  [bold]{k}[/bold].  {label}" for k, (_, label) in PROVIDERS.items()),
+                title="[bold cyan]Choose AI Provider[/bold cyan]",
+                border_style="cyan",
+                padding=(1, 2),
+            )
+        )
+        choice = Prompt.ask(
+            "Select", choices=list(PROVIDERS.keys()), default="1"
+        )
+        provider, label = PROVIDERS[choice]
+        console.print(f"[green]✔[/green]  {label}")
+        return provider