healspace 0.2.0__tar.gz → 0.3.0__tar.gz

{healspace-0.2.0 → healspace-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: healspace
-Version: 0.2.0
+Version: 0.3.0
 Summary: HealSpace — Guardian AI for Hugging Face Spaces
 Author: Onyxl · TeraBites
 License: Apache-2.0

healspace-0.3.0/healspace/__init__.py

@@ -0,0 +1,43 @@
+"""
+HealSpace — Guardian AI for Hugging Face Spaces
+================================================
+Automatically detects backend errors, heals common issues,
+and protects your Space with a branded lineage seal.
+
+Quick start — one line in app.py
+---------------------------------
+    import gradio as gr
+    from healspace import heal
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# My Space")
+        # ... your UI ...
+
+    heal(demo)          # wraps, protects, and launches
+    demo.launch()
+
+Mini AI code healer (context-aware)
+-------------------------------------
+    from healspace.brain import CodeHealer
+
+    healer = CodeHealer()
+    patch  = healer.heal_traceback(traceback_text, source_file="app.py")
+    print(patch)        # shows a diff
+    patch.apply()       # writes fix back to file
+"""
+
+from .core   import HealSpace, heal, diagnose, fix
+from .errors import KnownError, ErrorReport
+from .brain  import CodeHealer, CodePatch, StyleProfile
+
+__version__  = "0.3.0"
+__author__   = "Onyxl · TeraBites"
+__license__  = "Apache 2.0"
+__all__      = [
+    # guardian
+    "HealSpace", "heal", "diagnose", "fix",
+    # error types
+    "KnownError", "ErrorReport",
+    # mini AI
+    "CodeHealer", "CodePatch", "StyleProfile",
+]

healspace-0.3.0/healspace/brain.py

@@ -0,0 +1,692 @@
+"""
+healspace.brain — HealSpace Mini AI
+=====================================
+A lightweight, context-aware code healer.
+
+How it works
+------------
+1. **Understand** — reads the lines BEFORE and AFTER the error to learn:
+   - indentation style (tabs vs spaces, width)
+   - naming convention (snake_case, camelCase, etc.)
+   - quote style (' vs ")
+   - whether type hints are used
+   - comment style (# inline, docstrings, etc.)
+
+2. **Diagnose** — matches the error against known patterns (from errors.py)
+   and extracts the exact line + file from the traceback.
+
+3. **Fix** — generates a drop-in replacement that:
+   - uses the SAME style as surrounding code
+   - is minimal (touches only what's broken)
+   - includes a short inline comment explaining the fix
+
+4. **Apply** (optional) — writes the fix back to the source file in-place.
+
+Public API
+----------
+    from healspace.brain import CodeHealer
+
+    healer = CodeHealer()
+    patch  = healer.heal_traceback(traceback_text, source_file="app.py")
+    print(patch.fixed_line)
+    patch.apply()           # writes fix to file
+"""
+from __future__ import annotations
+
+import re
+import ast
+import textwrap
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, List, Dict, Tuple
+
+from .errors import KnownError, ErrorReport
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Style fingerprint
+# ─────────────────────────────────────────────────────────────────────────────
+
+@dataclass
+class StyleProfile:
+    """Describes the coding style of a block of source code."""
+    indent_char:    str  = " "      # " " or "\t"
+    indent_width:   int  = 4        # spaces per level (irrelevant if tabs)
+    quote_char:     str  = '"'      # dominant quote character
+    uses_type_hints:bool = False
+    naming:         str  = "snake"  # "snake" | "camel" | "pascal" | "mixed"
+    trailing_comma: bool = False
+    max_line_len:   int  = 88
+
+    def indent(self, level: int = 1) -> str:
+        if self.indent_char == "\t":
+            return "\t" * level
+        return " " * (self.indent_width * level)
+
+    def q(self, s: str) -> str:
+        """Wrap string literal in the dominant quote style."""
+        return f"{self.quote_char}{s}{self.quote_char}"
+
+
+def _detect_style(lines: List[str]) -> StyleProfile:
+    """Infer StyleProfile from a list of source lines."""
+    profile = StyleProfile()
+
+    # ── Indentation ──────────────────────────────────────────────────────────
+    tab_lines   = sum(1 for l in lines if l.startswith("\t"))
+    space_lines = sum(1 for l in lines if l.startswith("  "))
+    if tab_lines > space_lines:
+        profile.indent_char  = "\t"
+        profile.indent_width = 1
+    else:
+        profile.indent_char = " "
+        # detect width from the smallest non-zero indent
+        widths = []
+        for l in lines:
+            stripped = l.lstrip(" ")
+            w = len(l) - len(stripped)
+            if w > 0:
+                widths.append(w)
+        if widths:
+            profile.indent_width = min(widths)
+
+    # ── Quote style ──────────────────────────────────────────────────────────
+    singles = sum(l.count("'") for l in lines)
+    doubles = sum(l.count('"') for l in lines)
+    profile.quote_char = "'" if singles > doubles else '"'
+
+    # ── Type hints ───────────────────────────────────────────────────────────
+    profile.uses_type_hints = any(
+        re.search(r"def \w+\(.*:.*\) ->|: int|: str|: bool|: float|: list|: dict",
+                  l) for l in lines
+    )
+
+    # ── Naming convention ────────────────────────────────────────────────────
+    names = re.findall(r"\b([a-zA-Z_]\w*)\b", " ".join(lines))
+    snake  = sum(1 for n in names if "_" in n and n == n.lower())
+    camel  = sum(1 for n in names if re.match(r"[a-z][a-zA-Z0-9]*[A-Z]", n))
+    pascal = sum(1 for n in names if re.match(r"[A-Z][a-z]", n))
+    if snake >= camel and snake >= pascal:
+        profile.naming = "snake"
+    elif camel > pascal:
+        profile.naming = "camel"
+    else:
+        profile.naming = "pascal"
+
+    # ── Trailing commas ──────────────────────────────────────────────────────
+    profile.trailing_comma = any(re.search(r",\s*[\)\]\}]", l) for l in lines)
+
+    # ── Max line length ──────────────────────────────────────────────────────
+    lens = [len(l.rstrip()) for l in lines if l.strip()]
+    if lens:
+        profile.max_line_len = max(79, min(120, max(lens)))
+
+    return profile
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Fix generators — one per error type
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _fix_missing_dep(
+    report: ErrorReport,
+    broken_line: str,
+    style: StyleProfile,
+    context_before: List[str],
+) -> str:
+    """
+    ModuleNotFoundError → add a try/except import that falls back gracefully,
+    matching the surrounding import block style.
+    """
+    pkg = report.title.split(": ", 1)[-1].strip()
+    q   = style.quote_char
+
+    # Is the broken line a plain `import X` or `from X import Y`?
+    m_from   = re.match(r"^(\s*)(from\s+\S+\s+import\s+.+)$", broken_line)
+    m_import = re.match(r"^(\s*)(import\s+\S+.*)$", broken_line)
+
+    if m_from:
+        ind, stmt = m_from.group(1), m_from.group(2)
+        return (
+            f"{ind}try:\n"
+            f"{ind}    {stmt}\n"
+            f"{ind}except ImportError:\n"
+            f"{ind}    raise ImportError(\n"
+            f"{ind}        {q}HealSpace: {pkg!r} is missing. \"\n"
+            f"{ind}        \"Add {q}{pkg}{q} to requirements.txt and restart the Space.{q}\n"
+            f"{ind}    )\n"
+        )
+    elif m_import:
+        ind, stmt = m_import.group(1), m_import.group(2)
+        alias = re.sub(r"import\s+(\S+).*", r"\1", stmt).split(".")[0]
+        return (
+            f"{ind}try:\n"
+            f"{ind}    {stmt}\n"
+            f"{ind}except ImportError:\n"
+            f"{ind}    {alias} = None  "
+            f"# HealSpace: install {q}{pkg}{q} to enable this feature\n"
+        )
+    else:
+        ind = re.match(r"^(\s*)", broken_line).group(1)
+        return (
+            f"{ind}# HealSpace fix: '{pkg}' not found — "
+            f"add it to requirements.txt\n"
+            f"{broken_line}"
+        )
+
+
+def _fix_port_conflict(
+    report: ErrorReport,
+    broken_line: str,
+    style: StyleProfile,
+    context_before: List[str],
+) -> str:
+    """
+    Port already in use → add server_port with a fallback scan,
+    or wrap launch() with a retry loop matching existing style.
+    """
+    ind = re.match(r"^(\s*)", broken_line).group(1)
+    q   = style.quote_char
+
+    # If the broken line is a .launch() call, patch it
+    if "launch" in broken_line:
+        # Extract existing kwargs
+        has_share = "share" in broken_line
+        share_kw  = ", share=True" if has_share else ""
+        return (
+            f"{ind}# HealSpace fix: auto-find a free port if 7860 is taken\n"
+            f"{ind}import socket as _hs_sock\n"
+            f"{ind}def _hs_free_port(start=7860):\n"
+            f"{ind}    for p in range(start, start + 20):\n"
+            f"{ind}        try:\n"
+            f"{ind}            _hs_sock.socket().bind(({q}0.0.0.0{q}, p)); return p\n"
+            f"{ind}        except OSError:\n"
+            f"{ind}            continue\n"
+            f"{ind}    return start\n"
+            f"{ind}demo.launch(server_port=_hs_free_port(){share_kw})\n"
+        )
+    return (
+        f"{ind}# HealSpace fix: port conflict — restart Space or change server_port\n"
+        f"{broken_line}"
+    )
+
+
+def _fix_gpu_oom(
+    report: ErrorReport,
+    broken_line: str,
+    style: StyleProfile,
+    context_before: List[str],
+) -> str:
+    """CUDA OOM → wrap the offending call with empty_cache + half-precision hint."""
+    ind = re.match(r"^(\s*)", broken_line).group(1)
+    return (
+        f"{ind}# HealSpace fix: clear CUDA cache before this call\n"
+        f"{ind}try:\n"
+        f"{ind}    import torch as _hs_torch; _hs_torch.cuda.empty_cache()\n"
+        f"{ind}except Exception:\n"
+        f"{ind}    pass\n"
+        f"{broken_line}"
+    )
+
+
+def _fix_syntax_error(
+    report: ErrorReport,
+    broken_line: str,
+    style: StyleProfile,
+    context_before: List[str],
+) -> str:
+    """
+    SyntaxError → attempt common automatic repairs:
+    - unmatched brackets
+    - missing colon after def/class/if/for/while/with/else/elif/except/finally
+    - obvious string not closed
+    """
+    line = broken_line.rstrip()
+    ind  = re.match(r"^(\s*)", line).group(1)
+    fixed = line
+
+    # Missing colon
+    if re.match(
+        r"^\s*(def |class |if |elif |else|for |while |with |try|except|finally)",
+        line
+    ) and not line.rstrip().endswith(":"):
+        fixed = line.rstrip() + ":"
+
+    # Unbalanced brackets — add missing closers
+    opens  = {"(": ")", "[": "]", "{": "}"}
+    stack  = []
+    in_str = False
+    str_ch = None
+    for ch in fixed:
+        if in_str:
+            if ch == str_ch:
+                in_str = False
+        else:
+            if ch in ('"', "'"):
+                in_str = True; str_ch = ch
+            elif ch in opens:
+                stack.append(opens[ch])
+            elif ch in opens.values() and stack and stack[-1] == ch:
+                stack.pop()
+    if stack:
+        fixed = fixed.rstrip() + "".join(reversed(stack))
+
+    if fixed != line:
+        return (
+            f"{ind}# HealSpace fix: auto-corrected syntax\n"
+            f"{fixed}\n"
+        )
+    # Can't auto-fix — leave with comment
+    return (
+        f"{ind}# HealSpace: syntax error here — check brackets, colons, and quotes\n"
+        f"{broken_line}"
+    )
+
+
+def _fix_auth_error(
+    report: ErrorReport,
+    broken_line: str,
+    style: StyleProfile,
+    context_before: List[str],
+) -> str:
+    """Auth error → inject HF_TOKEN env lookup before the offending call."""
+    ind = re.match(r"^(\s*)", broken_line).group(1)
+    q   = style.quote_char
+    return (
+        f"{ind}# HealSpace fix: ensure HF_TOKEN is set as a Space secret\n"
+        f"{ind}import os as _hs_os\n"
+        f"{ind}if not _hs_os.environ.get({q}HF_TOKEN{q}):\n"
+        f"{ind}    raise EnvironmentError(\n"
+        f"{ind}        {q}HealSpace: Add HF_TOKEN as a secret in Space Settings.{q}\n"
+        f"{ind}    )\n"
+        f"{broken_line}"
+    )
+
+
+def _fix_runtime_error(
+    report: ErrorReport,
+    broken_line: str,
+    style: StyleProfile,
+    context_before: List[str],
+) -> str:
+    """Generic RuntimeError → wrap in try/except with descriptive re-raise."""
+    ind = re.match(r"^(\s*)", broken_line).group(1)
+    q   = style.quote_char
+    desc = report.description[:80].replace(q, "\\" + q)
+    return (
+        f"{ind}# HealSpace fix: guarded against RuntimeError\n"
+        f"{ind}try:\n"
+        f"{ind}    {broken_line.strip()}\n"
+        f"{ind}except RuntimeError as _hs_e:\n"
+        f"{ind}    print(f{q}[HealSpace] RuntimeError caught: {{_hs_e}}{q})\n"
+        f"{ind}    raise\n"
+    )
+
+
+_FIX_GENERATORS: Dict[str, callable] = {
+    "missing_dep":   _fix_missing_dep,
+    "port_conflict": _fix_port_conflict,
+    "gpu_oom":       _fix_gpu_oom,
+    "syntax_error":  _fix_syntax_error,
+    "auth_error":    _fix_auth_error,
+    "runtime_error": _fix_runtime_error,
+}
+
+# fallback for error types without a dedicated generator
+def _fix_generic(
+    report: ErrorReport,
+    broken_line: str,
+    style: StyleProfile,
+    context_before: List[str],
+) -> str:
+    ind = re.match(r"^(\s*)", broken_line).group(1)
+    return (
+        f"{ind}# HealSpace: {report.title}\n"
+        f"{ind}# Suggested: {report.fixes[0] if report.fixes else 'see traceback'}\n"
+        f"{broken_line}"
+    )
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Patch dataclass
+# ─────────────────────────────────────────────────────────────────────────────
+
+@dataclass
+class CodePatch:
+    """
+    A ready-to-apply code fix produced by CodeHealer.
+
+    Attributes
+    ----------
+    source_file  : path to the file that was healed (may be None)
+    error_line   : 1-based line number of the broken line
+    original     : the original broken line(s)
+    fixed        : the replacement code (may span multiple lines)
+    report       : the ErrorReport that triggered this fix
+    style        : the StyleProfile inferred from surrounding code
+    context_before : lines above the error (for display)
+    context_after  : lines below the error (for display)
+    """
+    source_file:    Optional[str]
+    error_line:     int
+    original:       str
+    fixed:          str
+    report:         ErrorReport
+    style:          StyleProfile
+    context_before: List[str] = field(default_factory=list)
+    context_after:  List[str]  = field(default_factory=list)
+
+    # ── Display ───────────────────────────────────────────────────────────
+
+    def diff(self) -> str:
+        """Return a human-readable unified-diff-style patch."""
+        sep = "─" * 60
+        lines = [
+            sep,
+            f"  HealSpace AI — {self.report.title}",
+            f"  File: {self.source_file or '(unknown)'}  line {self.error_line}",
+            sep,
+            "",
+        ]
+        for l in self.context_before[-3:]:
+            lines.append(f"  {l.rstrip()}")
+        for l in self.original.splitlines():
+            lines.append(f"- {l.rstrip()}")
+        for l in self.fixed.splitlines():
+            lines.append(f"+ {l.rstrip()}")
+        for l in self.context_after[:3]:
+            lines.append(f"  {l.rstrip()}")
+        lines += ["", f"  Style: indent={self.style.indent_width}sp  "
+                  f"quotes={self.style.quote_char}  "
+                  f"hints={self.style.uses_type_hints}  "
+                  f"naming={self.style.naming}", sep]
+        return "\n".join(lines)
+
+    def apply(self, dry_run: bool = False) -> bool:
+        """
+        Write the fix back to *source_file* in-place.
+
+        Parameters
+        ----------
+        dry_run : bool
+            If True, print what would change but don't write.
+
+        Returns
+        -------
+        True if the file was (or would be) modified, False otherwise.
+        """
+        if not self.source_file:
+            print("[HealSpace Brain] No source file — cannot apply patch.")
+            return False
+
+        path = Path(self.source_file)
+        if not path.exists():
+            print(f"[HealSpace Brain] File not found: {path}")
+            return False
+
+        lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+        idx   = self.error_line - 1          # 0-based
+        if idx < 0 or idx >= len(lines):
+            print(f"[HealSpace Brain] Line {self.error_line} out of range.")
+            return False
+
+        fixed_lines = [
+            l if l.endswith("\n") else l + "\n"
+            for l in self.fixed.splitlines()
+        ]
+
+        if dry_run:
+            print(self.diff())
+            print("[HealSpace Brain] (dry run — file not modified)")
+            return True
+
+        lines[idx : idx + 1] = fixed_lines
+        path.write_text("".join(lines), encoding="utf-8")
+        print(f"[HealSpace Brain] ✅ Patch applied → {path}  (line {self.error_line})")
+        return True
+
+    def __str__(self) -> str:
+        return self.diff()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Traceback parser
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _parse_traceback(tb: str) -> Tuple[Optional[str], Optional[int], Optional[str]]:
+    """
+    Extract (filename, lineno, line_text) from a Python traceback string.
+    Returns the INNERMOST (deepest) frame, which is the root cause.
+    """
+    # Matches:  File "app.py", line 42, in some_func
+    frame_re  = re.compile(r'File "([^"]+)", line (\d+)')
+    line_re   = re.compile(r'^\s{4}(.+)$')          # the code line after the frame
+
+    matches = list(frame_re.finditer(tb))
+    if not matches:
+        return None, None, None
+
+    # Take the last frame
+    m        = matches[-1]
+    filename = m.group(1)
+    lineno   = int(m.group(2))
+
+    # The line of code is the next non-empty line after the frame header
+    after     = tb[m.end():]
+    code_line = None
+    for raw in after.splitlines():
+        stripped = raw.strip()
+        if stripped and not stripped.startswith("^") and not stripped.startswith("~"):
+            code_line = raw
+            break
+
+    return filename, lineno, code_line
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Main healer
+# ─────────────────────────────────────────────────────────────────────────────
+
+class CodeHealer:
+    """
+    HealSpace Mini AI — context-aware code fixer.
+
+    Parameters
+    ----------
+    context_window : int
+        How many lines above and below the error to read for style analysis
+        and context display (default 15).
+    auto_apply : bool
+        If True, automatically write fixes back to source files (default False).
+    verbose : bool
+        Print detailed logs (default True).
+
+    Example
+    -------
+    >>> from healspace.brain import CodeHealer
+    >>> healer = CodeHealer()
+    >>> patch = healer.heal_traceback(traceback_text, source_file="app.py")
+    >>> print(patch)          # diff view
+    >>> patch.apply()         # write fix to file
+    """
+
+    def __init__(
+        self,
+        context_window: int  = 15,
+        auto_apply:     bool = False,
+        verbose:        bool = True,
+    ):
+        self.context_window = context_window
+        self.auto_apply     = auto_apply
+        self.verbose        = verbose
+
+    # ── Internal helpers ──────────────────────────────────────────────────
+
+    def _read_context(
+        self, filepath: str, lineno: int
+    ) -> Tuple[List[str], str, List[str]]:
+        """
+        Read (lines_before, broken_line, lines_after) from *filepath*.
+        Falls back gracefully if the file can't be read.
+        """
+        try:
+            all_lines = Path(filepath).read_text(encoding="utf-8").splitlines()
+        except Exception:
+            return [], "", []
+
+        idx    = lineno - 1          # 0-based
+        before = all_lines[max(0, idx - self.context_window) : idx]
+        broken = all_lines[idx] if idx < len(all_lines) else ""
+        after  = all_lines[idx + 1 : idx + 1 + self.context_window]
+        return before, broken, after
+
+    def _generate_fix(
+        self,
+        report:         ErrorReport,
+        broken_line:    str,
+        style:          StyleProfile,
+        context_before: List[str],
+    ) -> str:
+        """Dispatch to the appropriate fix generator."""
+        generator = _FIX_GENERATORS.get(report.error_type, _fix_generic)
+        return generator(report, broken_line, style, context_before)
+
+    # ── Public API ────────────────────────────────────────────────────────
+
+    def heal_traceback(
+        self,
+        traceback_text: str,
+        source_file:    Optional[str] = None,
+    ) -> Optional[CodePatch]:
+        """
+        Full healing pipeline:
+          parse traceback → diagnose → read context → detect style → generate fix.
+
+        Parameters
+        ----------
+        traceback_text : str
+            The full Python traceback (as printed to stderr).
+        source_file : str, optional
+            Override the filename from the traceback (useful in Gradio callbacks
+            where the path is /tmp/...).
+
+        Returns
+        -------
+        CodePatch if a fix was generated, None if the error was unrecognised.
+        """
+        if self.verbose:
+            print("[HealSpace Brain] 🧠 Analysing traceback…")
+
+        # 1. Diagnose
+        report = KnownError.match(traceback_text)
+        if report is None:
+            if self.verbose:
+                print("[HealSpace Brain] No known error pattern matched.")
+            return None
+
+        if self.verbose:
+            print(f"[HealSpace Brain] 🔍 Detected: {report.title}")
+
+        # 2. Parse traceback for file + line
+        tb_file, lineno, tb_code_line = _parse_traceback(traceback_text)
+        filepath = source_file or tb_file
+        lineno   = lineno or 1
+
+        # 3. Read surrounding code from file
+        context_before, broken_line, context_after = [], "", []
+        if filepath:
+            context_before, broken_line, context_after = self._read_context(
+                filepath, lineno
+            )
+
+        # If we couldn't read the file, use the line from the traceback itself
+        if not broken_line and tb_code_line:
+            broken_line = tb_code_line.strip()
+
+        if not broken_line:
+            broken_line = f"# (line {lineno} — source unavailable)"
+
+        # 4. Detect style from surrounding code
+        all_context = context_before + [broken_line] + context_after
+        style = _detect_style(all_context)
+
+        if self.verbose:
+            print(
+                f"[HealSpace Brain] 📐 Style: "
+                f"indent={style.indent_width}{'tab' if style.indent_char == chr(9) else 'sp'}  "
+                f"quotes={style.quote_char}  "
+                f"type_hints={style.uses_type_hints}  "
+                f"naming={style.naming}"
+            )
+
+        # 5. Generate fix
+        fixed = self._generate_fix(report, broken_line, style, context_before)
+
+        if self.verbose:
+            print(f"[HealSpace Brain] 🔧 Fix generated for line {lineno}")
+
+        patch = CodePatch(
+            source_file    = filepath,
+            error_line     = lineno,
+            original       = broken_line,
+            fixed          = fixed,
+            report         = report,
+            style          = style,
+            context_before = context_before,
+            context_after  = context_after,
+        )
+
+        if self.auto_apply:
+            patch.apply()
+
+        return patch
+
+    def heal_file(
+        self,
+        source_file: str,
+        traceback_text: str,
+    ) -> Optional[CodePatch]:
+        """Convenience wrapper — same as heal_traceback with source_file forced."""
+        return self.heal_traceback(traceback_text, source_file=source_file)
+
+    def heal_code(
+        self,
+        code: str,
+        error_text: str,
+        lineno: int = 1,
+    ) -> Optional[CodePatch]:
+        """
+        Heal an in-memory code string without a file on disk.
+
+        Parameters
+        ----------
+        code       : full source code as a string
+        error_text : error message or traceback
+        lineno     : 1-based line number of the broken line
+
+        Returns
+        -------
+        CodePatch (source_file=None, apply() will no-op)
+        """
+        report = KnownError.match(error_text)
+        if report is None:
+            return None
+
+        lines        = code.splitlines()
+        idx          = lineno - 1
+        broken_line  = lines[idx] if 0 <= idx < len(lines) else ""
+        before       = lines[max(0, idx - self.context_window) : idx]
+        after        = lines[idx + 1 : idx + 1 + self.context_window]
+        style        = _detect_style(before + [broken_line] + after)
+        fixed        = self._generate_fix(report, broken_line, style, before)
+
+        return CodePatch(
+            source_file    = None,
+            error_line     = lineno,
+            original       = broken_line,
+            fixed          = fixed,
+            report         = report,
+            style          = style,
+            context_before = before,
+            context_after  = after,
+        )

{healspace-0.2.0 → healspace-0.3.0}/healspace/core.py

@@ -12,9 +12,12 @@ import subprocess
 from typing import Optional, List, Callable
 
 from .errors import KnownError, ErrorReport
+from .brain  import CodeHealer, CodePatch
 
 # ── Lineage seal ──────────────────────────────────────────────────────────────
-SEAL = "🛡️ Protected by HealSpace"
+SEAL      = "🛡️ Protected by HealSpace"
+SEAL_URL  = "https://pypi.org/project/healspace/"
+SEAL_MD   = "🛡️ Protected by HealSpace — [click here to learn more](https://pypi.org/project/healspace/)"
 
 # ── Auto-fix actions ──────────────────────────────────────────────────────────
 
@@ -221,7 +224,7 @@ class HealSpace:
                     for r in reports:
                         lines.append(str(r))
                         lines.append("")
-                    lines.append(SEAL)
+                    lines.append(f"{SEAL} — learn more: {SEAL_URL}")
                     return "\n".join(lines)
 
                 def _trigger_error() -> str:
@@ -236,7 +239,71 @@ class HealSpace:
                 heal_btn.click (_run_heal,      inputs=log_input, outputs=output_box)
                 error_btn.click(_trigger_error, inputs=None,      outputs=output_box)
 
-            gr.Markdown(f"<center><sub>{SEAL}</sub></center>")
+            # ── Mini AI Code Healer panel ──────────────────────────────────
+            with gr.Accordion("🧠 HealSpace AI — Code Healer", open=False):
+                gr.Markdown(
+                    "Paste a **traceback** and the **broken source code** below.\n\n"
+                    "The AI reads the style of your code (indentation, quotes, naming, "
+                    "type hints) and writes a drop-in fix that matches it perfectly."
+                )
+                with gr.Row():
+                    ai_tb_input = gr.Textbox(
+                        label       = "Traceback / Error",
+                        placeholder = "Paste the full traceback here…",
+                        lines       = 6,
+                    )
+                    ai_code_input = gr.Textbox(
+                        label       = "Source Code (optional — paste the full file)",
+                        placeholder = "Paste your app.py or the relevant module here…",
+                        lines       = 6,
+                    )
+                ai_lineno = gr.Number(
+                    label   = "Error line number (from traceback)",
+                    value   = 1,
+                    minimum = 1,
+                    step    = 1,
+                    precision = 0,
+                )
+                ai_btn    = gr.Button("🧠 Analyse & Generate Fix", variant="primary")
+                ai_output = gr.Code(
+                    label    = "HealSpace AI — Generated Fix",
+                    language = "python",
+                    lines    = 14,
+                    interactive = True,
+                )
+                ai_diff   = gr.Textbox(
+                    label    = "Diff View",
+                    lines    = 10,
+                    interactive = False,
+                )
+
+                def _run_ai_heal(tb_text: str, code_text: str, lineno: int) -> tuple:
+                    healer = CodeHealer(verbose=False)
+                    if code_text.strip():
+                        patch = healer.heal_code(
+                            code      = code_text,
+                            error_text = tb_text,
+                            lineno     = max(1, int(lineno)),
+                        )
+                    elif tb_text.strip():
+                        patch = healer.heal_traceback(tb_text)
+                    else:
+                        return ("# Paste a traceback above first.", "")
+                    if patch is None:
+                        return (
+                            "# HealSpace AI: no known error pattern matched.\n"
+                            "# Try pasting more of the traceback.",
+                            "",
+                        )
+                    return patch.fixed, patch.diff()
+
+                ai_btn.click(
+                    _run_ai_heal,
+                    inputs  = [ai_tb_input, ai_code_input, ai_lineno],
+                    outputs = [ai_output, ai_diff],
+                )
+
+            gr.Markdown(f"<center><sub>{SEAL_MD}</sub></center>")
 
         return self
 

{healspace-0.2.0 → healspace-0.3.0}/healspace.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: healspace
-Version: 0.2.0
+Version: 0.3.0
 Summary: HealSpace — Guardian AI for Hugging Face Spaces
 Author: Onyxl · TeraBites
 License: Apache-2.0

{healspace-0.2.0 → healspace-0.3.0}/healspace.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 healspace/__init__.py
+healspace/brain.py
 healspace/core.py
 healspace/errors.py
 healspace.egg-info/PKG-INFO

{healspace-0.2.0 → healspace-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "healspace"
-version = "0.2.0"
+version = "0.3.0"
 description = "HealSpace — Guardian AI for Hugging Face Spaces"
 readme = "README.md"
 license = { text = "Apache-2.0" }

healspace-0.2.0/healspace/__init__.py

@@ -1,34 +0,0 @@
-"""
-HealSpace — Guardian AI for Hugging Face Spaces
-================================================
-Automatically detects backend errors, heals common issues,
-and protects your Space with a branded lineage seal.
-
-Quick start
------------
-In your Space's app.py, wrap your Gradio app:
-
-    import gradio as gr
-    from healspace import heal
-
-    with gr.Blocks() as demo:
-        gr.Markdown("# My Space")
-        # ... your UI ...
-
-    heal(demo)          # wraps, protects, and launches
-    demo.launch()
-
-Or use the standalone guardian (non-Gradio):
-
-    from healspace import HealSpace
-    hs = HealSpace()
-    hs.watch()          # starts background health monitor
-"""
-
-from .core   import HealSpace, heal, diagnose, fix
-from .errors import KnownError, ErrorReport
-
-__version__  = "0.2.0"
-__author__   = "Onyxl · TeraBites"
-__license__  = "Apache 2.0"
-__all__      = ["HealSpace", "heal", "diagnose", "fix", "KnownError", "ErrorReport"]