codesuture 0.5.0__py3-none-any.whl

codesuture/tracer.py

@@ -0,0 +1,447 @@
+import sys
+import os
+import json
+from datetime import datetime
+from codesuture.pattern_matcher import analyze_exception
+from codesuture.guard_synthesizer import synthesize_guarded_code
+from codesuture.code_replacer import replace_function_code, get_function_from_frame
+from codesuture.rewind import rewind_frame_to_start
+
+_PYTHON_PREFIX = os.path.normcase(os.path.abspath(sys.prefix)) + os.sep
+_PYTHON_BASE_PREFIX = os.path.normcase(os.path.abspath(sys.base_prefix)) + os.sep
+
+def _is_internal_frame(frame):
+
+    co_filename = frame.f_code.co_filename
+
+    if co_filename.startswith('<'):
+        return True
+
+    try:
+        norm = os.path.normcase(os.path.abspath(co_filename))
+        if norm.startswith(_PYTHON_PREFIX) or norm.startswith(_PYTHON_BASE_PREFIX):
+            return True
+    except (ValueError, OSError):
+        pass
+    return False
+
+class CodeSutureTracer:
+    def __init__(self, dry_run=False, log_file=None, max_retries=3, autonomous=False, script_path=None, verbose=False, shadow=False, ttl=7):
+        self.dry_run = dry_run
+        self.log_file = log_file
+        self.max_retries = max_retries
+        self.autonomous = autonomous
+        self.script_path = script_path
+        self.verbose = verbose
+        self.shadow_mode = shadow
+        self.ttl = ttl
+        self._patched_codes = {}  
+        self.attempts = {}  
+        self.stats = {
+            "patched": 0,
+            "dry_run_suggestions": 0,
+            "self_healed": 0
+        }
+        self.patched_signatures = {}  
+        self._handled_exc_ids = set()  
+
+    def __call__(self, frame, event, arg):
+        if event == 'return' and self.shadow_mode and frame.f_code in self._patched_codes:
+            from codesuture.shadow import shadow_check
+            func_name = frame.f_code.co_name
+            guard_type = self._patched_codes[frame.f_code]
+            shadow_check(func_name, arg, guard_type)
+            return self
+
+        if event == 'exception':
+            exc_type, exc_value, exc_tb = arg
+            self._handle_exception(frame, exc_type, exc_value, exc_tb)
+            return self
+        return self
+
+    def _extract_crash_key(self, exc_type, exc_value):
+
+        import re
+        if exc_type.__name__ == 'KeyError':
+            return str(exc_value).strip("'\"")
+        elif exc_type.__name__ == 'AttributeError':
+            m = re.search(r"has no attribute '(\w+)'", str(exc_value))
+            if m:
+                return m.group(1)
+        elif exc_type.__name__ == 'TypeError':
+            m = re.search(r"'NoneType' object is not subscriptable", str(exc_value))
+            if m:
+                return '__subscript__'
+        return None
+
+    def _handle_exception(self, frame, exc_type, exc_value, exc_tb, thread=None):
+
+        if _is_internal_frame(frame):
+            return
+
+        from codesuture.persistence import HEALED_FUNCTIONS, _heal_key
+        from codesuture.code_replacer import get_function_from_frame
+        try:
+            func = get_function_from_frame(frame)
+            if func is not None:
+                func_name = getattr(func, '__qualname__', func.__name__)
+                module_name = getattr(func, '__module__', '__main__')
+                crash_key = self._extract_crash_key(exc_type, exc_value)
+                if _heal_key(module_name, func_name, crash_key) in HEALED_FUNCTIONS:
+                    return
+        except Exception:
+            pass
+
+        exc_id = id(exc_value)
+        if exc_id in self._handled_exc_ids:
+            return
+
+        spec = None
+        from codesuture.fingerprint import compute_fingerprint, lookup, record
+        fp = compute_fingerprint(frame.f_code, frame.f_lasti, exc_type.__name__)
+        cached = lookup(fp)
+        if cached:
+            print(f"[CodeSuture] Known crash pattern #{fp[:8]} -- "
+                  f"applying cached {cached['guard_type']} guard directly.")
+            from codesuture.pattern_matcher import PatchSpec
+
+            spec = PatchSpec(
+                strategy=cached['guard_type'],
+                var_name=cached['target'],
+                default_value=cached.get('default_value', None),
+                key_name=tuple(cached.get('key_name')) if isinstance(cached.get('key_name'), list) else cached.get('key_name', None)
+            )
+
+        if spec is None:
+            try:
+                spec = analyze_exception(frame, exc_type, exc_value, exc_tb)
+            except Exception as internal_exc:
+
+                spec = self._self_heal(internal_exc)
+                if spec is None:
+                    return
+
+                try:
+                    spec = analyze_exception(frame, exc_type, exc_value, exc_tb)
+                except Exception:
+                    return
+
+        if spec is None:
+
+            from codesuture.pattern_matcher import check_learned_rules
+            func = get_function_from_frame(frame)
+            if func is not None:
+                func_name = getattr(func, '__qualname__', func.__name__)
+                spec = check_learned_rules(func_name, exc_type.__name__, str(exc_value))
+
+        if spec is None and self.autonomous and func is not None:
+
+            print(f"[CodeSuture] Autonomous mode activated for unknown error: {exc_type.__name__}")
+            import traceback
+            from codesuture.code_replacer import get_source_from_frame
+            from codesuture.plugins.autonomous import propose_fix
+            from codesuture.sandbox import test_fix
+            from codesuture.knowledge import save_learned_rule
+            from codesuture.pattern_matcher import PatchSpec
+
+            tb_text = "".join(traceback.format_exception(exc_type, exc_value, exc_tb))
+            function_source = get_source_from_frame(frame)
+
+            new_source = propose_fix(tb_text, function_source, exc_type.__name__, str(exc_value))
+
+            module_name = getattr(func, '__module__', '__main__')
+
+            if test_fix(self.script_path, module_name, func_name, new_source, exc_type.__name__):
+                print(f"[CodeSuture] LLM fix PASSED sandbox. Learning rule for {func_name}.")
+                save_learned_rule(exc_type.__name__, str(exc_value), func_name, new_source)
+                spec = PatchSpec(
+                    strategy='autonomous_rule',
+                    var_name=func_name,
+                    default_value=new_source
+                )
+            else:
+                print("[CodeSuture] LLM fix FAILED sandbox. Skipping autonomous patch.")
+
+        if spec is None:
+            return
+
+        key = (id(frame.f_code), frame.f_lasti)
+        tries = self.attempts.get(key, 0)
+        if tries >= self.max_retries:
+            print(f"[CodeSuture] Max retries ({self.max_retries}) reached at "
+                  f"{frame.f_code.co_name}:{frame.f_lineno}, giving up.")
+            return
+
+        self.attempts[key] = tries + 1
+
+        _thread_name = thread.name if thread is not None else None
+
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "function": frame.f_code.co_name,
+            "filename": frame.f_code.co_filename,
+            "lineno": frame.f_lineno,
+            "exception": f"{exc_type.__name__}: {exc_value}",
+            "strategy": spec.strategy,
+            "var_name": spec.var_name,
+            "default": repr(spec.default_value),
+        }
+        if _thread_name is not None:
+            entry["thread"] = _thread_name
+
+        display_name = spec.var_name
+        if spec.key_name:
+            display_name = spec.key_name[-1] if isinstance(spec.key_name, tuple) else spec.key_name
+        elif spec.strategy == 'null_guard' and exc_type.__name__ == 'AttributeError':
+            import re
+            m = re.search(r"has no attribute '(\w+)'", str(exc_value))
+            if m:
+                display_name = m.group(1)
+
+        if self.dry_run:
+            entry["action"] = "dry_run"
+            from codesuture.fingerprint import lookup as fp_lookup
+            fp_hit = fp_lookup(fp) if fp else None
+            if fp_hit:
+                try:
+                    import os as _os
+                    fp_file = ".codesuture_fingerprints"
+                    if _os.path.isfile(fp_file):
+                        with open(fp_file, "r", encoding="utf-8") as fpf:
+                            fp_data = json.load(fpf)
+                        count = fp_data.get(fp, {}).get("count", 1) if isinstance(fp_data.get(fp), dict) else 1
+                    else:
+                        count = 0
+                except Exception:
+                    count = 0
+            else:
+                count = 0
+            if count >= 3:
+                confidence = "HIGH"
+            elif count >= 1:
+                confidence = "MEDIUM"
+            else:
+                confidence = "LOW"
+            confidence_detail = (f"pattern seen {count}x in fingerprint registry" if count > 0
+                                 else "new pattern, not in fingerprint registry")
+            print(f"[CodeSuture DRY-RUN] Would apply {spec.strategy} on '{display_name}' in {frame.f_code.co_name}()")
+            print(f"[CodeSuture DRY-RUN] Confidence: {confidence} ({confidence_detail})")
+            print(f"  Default value: {repr(spec.default_value)}")
+            print(f"  Guard type: {spec.strategy}")
+            self._log(entry)
+            self.stats["dry_run_suggestions"] += 1
+            return
+        else:
+            print(f"[CodeSuture] Caught {exc_type.__name__}: {exc_value}")
+
+            sig = (spec.var_name, spec.key_name, spec.strategy, exc_type.__name__)
+            is_reuse = sig in self.patched_signatures
+
+            if is_reuse:
+                print(f"[CodeSuture] Reusing existing patch for '{display_name}' in {frame.f_code.co_name}()")
+                spec = self.patched_signatures[sig]
+
+            if not cached:
+                print(f"[CodeSuture] Applying {spec.strategy} on '{display_name}' ...")
+
+            try:
+                if getattr(spec, 'target_func', None):
+                    func = spec.target_func
+                    old_code = getattr(func, '__code__', frame.f_code)
+                else:
+                    func = get_function_from_frame(frame)
+                    old_code = frame.f_code
+
+                new_bc = synthesize_guarded_code(old_code, spec)
+                new_code = new_bc.to_code()
+                self._persist_patch(frame, old_code, new_code, func)
+
+                replace_function_code(func, new_code)
+
+                if getattr(spec, 'target_func', None):
+                    assert spec.target_func.__code__ is new_code, "Property fget code replacement failed"
+
+                from codesuture.persistence import save_patch
+                save_patch(func, new_code, spec, self.ttl)
+
+                if self.shadow_mode:
+                    self._patched_codes[new_code] = spec.strategy
+
+                if self.verbose:
+                    from codesuture.diff_guard import semantic_diff
+                    diff = semantic_diff(old_code, new_code, spec.strategy)
+                    print(f"[CodeSuture DEBUG] Diff: +{diff.added} -{diff.removed} instructions (allowed <= {diff.allowed})")
+
+                if not is_reuse:
+                    self.patched_signatures[sig] = spec
+
+                if not cached:
+                    record(fp, spec.strategy, spec.var_name, getattr(func, '__name__', 'unknown'), exc_type.__name__, spec.default_value, spec.key_name)
+
+                entry["action"] = "applied"
+                self._log(entry)
+                self.stats["patched"] += 1
+                self._handled_exc_ids.add(exc_id)
+                print(f"[CodeSuture] Patch applied to {getattr(func, '__name__', 'unknown')}().")
+                return
+            except Exception as e:
+                from codesuture.guard_synthesizer import PatchValidationError, PatchRejectedError
+                if isinstance(e, PatchValidationError):
+                    print(f"[CodeSuture] {e}")
+                    entry["action"] = "rejected"
+                elif isinstance(e, PatchRejectedError):
+                    entry["action"] = "rejected"
+                elif isinstance(e, RuntimeError) and old_code.co_flags & 0x100:
+                    print(f"[CodeSuture] WARNING: async patch for {old_code.co_name}() "
+                          f"raised RuntimeError: {e} -- aborting patch, not persisting.")
+                    entry["action"] = "aborted"
+                else:
+                    import traceback as _tb
+                    _tb.print_exc()
+                    print(f"[CodeSuture] Patch failed: {e}")
+                    entry["action"] = "failed"
+
+                entry["error"] = str(e)
+                self._log(entry)
+                return
+
+    def _self_heal(self, internal_exc):
+
+        import traceback as tb_mod
+        internal_tb = sys.exc_info()[2]
+        if internal_tb is None:
+            return None
+        curr = internal_tb
+        while curr.tb_next:
+            curr = curr.tb_next
+        internal_frame = curr.tb_frame
+
+        print(f"[CodeSuture] ENGINE SELF-HEAL: caught internal {type(internal_exc).__name__}: {internal_exc}")
+        print(f"[CodeSuture]   in {internal_frame.f_code.co_name}() at {internal_frame.f_code.co_filename}:{internal_frame.f_lineno}")
+
+        try:
+            spec = analyze_exception(
+                internal_frame, type(internal_exc), internal_exc, internal_tb
+            )
+        except Exception:
+            print("[CodeSuture]   self-heal analysis failed")
+            return None
+
+        if spec is None:
+            print("[CodeSuture]   no deterministic patch found for internal error")
+            return None
+
+        print(f"[CodeSuture]   Applying {spec.strategy} on '{spec.var_name}' …")
+        try:
+            func = get_function_from_frame(internal_frame)
+            new_bc = synthesize_guarded_code(internal_frame.f_code, spec)
+            new_code = new_bc.to_code()
+            replace_function_code(func, new_code)
+            self.stats["patched"] += 1
+            print(f"[CodeSuture]   Self-healed {func.__name__}().")
+
+            from codesuture.persistence import save_patch
+            save_patch(func, new_code)
+
+            return spec
+        except Exception as e:
+            print(f"[CodeSuture]   self-heal patch failed: {e}")
+            return None
+
+    def _persist_patch(self, frame, old_code, new_code, func=None):
+        import gc
+        import ctypes
+        replaced = False
+        propagated_count = 0
+
+        refs = gc.get_referrers(old_code)
+        for ref in refs:
+            if hasattr(ref, "__code__") and getattr(ref, "__code__", None) is old_code:
+                try:
+                    ref.__code__ = new_code
+                    replaced = True
+                    propagated_count += 1
+                except Exception:
+                    pass
+            elif hasattr(ref, "__func__"):
+                fn = getattr(ref, "__func__", None)
+                if hasattr(fn, "__code__") and getattr(fn, "__code__", None) is old_code:
+                    try:
+                        fn.__code__ = new_code
+                        replaced = True
+                        propagated_count += 1
+                    except Exception:
+                        pass
+            elif isinstance(ref, tuple):
+                for i, c in enumerate(ref):
+                    if c is old_code:
+                        try:
+                            addr = id(ref) + 24 + i * 8
+                            ctypes.c_void_p.from_address(addr).value = id(new_code)
+                            ctypes.pythonapi.Py_IncRef(ctypes.py_object(new_code))
+                            replaced = True
+                        except Exception:
+                            pass
+
+        if propagated_count > 0:
+            print(f"[CodeSuture] Propagated patch to {propagated_count} additional live reference(s) of {frame.f_code.co_name}.")
+        elif replaced:
+            print(f"[CodeSuture] In-memory propagated patch applied to {frame.f_code.co_name}.")
+        else:
+            if func is None:
+                func_name = frame.f_code.co_name
+                func = frame.f_globals.get(func_name)
+
+            if func and hasattr(func, "__code__") and getattr(func, "__code__", None) is old_code:
+                func.__code__ = new_code
+                print(f"[CodeSuture] In-memory propagated patch applied to {func.__name__}().")
+            else:
+                print("[CodeSuture] Could not find code object in memory to persist.")
+
+    def _log(self, entry):
+        if self.log_file:
+            with open(self.log_file, 'a', encoding='utf-8') as f:
+                json.dump(entry, f, default=str)
+                f.write('\n')
+
+    def report(self):
+        print("\n[CodeSuture] Session summary:")
+        print(f"  Patches applied: {len(self.patched_signatures)}")
+        if self.dry_run:
+            print(f"  Dry-run suggestions: {self.stats['dry_run_suggestions']}")
+            print(f"[CodeSuture DRY-RUN] No patches applied. Run without --dry-run to apply.")
+
+_original_excepthook = None
+
+def _codesuture_excepthook(tracer, exc_type, exc_value, exc_tb):
+    import threading
+    if exc_tb:
+        tracer._handle_exception(exc_tb.tb_frame, exc_type, exc_value, exc_tb, thread=threading.current_thread())
+
+    if _original_excepthook:
+        _original_excepthook(exc_type, exc_value, exc_tb)
+    else:
+        sys.__excepthook__(exc_type, exc_value, exc_tb)
+
+def install(dry_run=False, log_file=None, max_retries=3, autonomous=False, script_path=None, verbose=False, shadow=False, ttl=7):
+    global _original_excepthook
+    import threading
+    tracer = CodeSutureTracer(dry_run, log_file, max_retries, autonomous, script_path, verbose, shadow, ttl)
+    sys.settrace(tracer)
+    threading.settrace(tracer)
+
+    if getattr(threading, 'excepthook', None) is not None:
+        if threading.excepthook != getattr(threading, '__excepthook__', None):
+             _original_excepthook = threading.excepthook
+        threading.excepthook = lambda args: _codesuture_excepthook(tracer, args.exc_type, args.exc_value, args.exc_traceback)
+
+    return tracer
+
+def uninstall():
+    global _original_excepthook
+    sys.settrace(None)
+    import threading
+    threading.settrace(None)
+    if getattr(threading, 'excepthook', None) is not None:
+        threading.excepthook = _original_excepthook or getattr(threading, '__excepthook__', sys.__excepthook__)
+        _original_excepthook = None

codesuture/watcher.py

@@ -0,0 +1,78 @@
+
+import subprocess
+import sys
+import time
+
+def watch(script, max_restarts=10, shadow=False, verbose=False):
+
+    restarts = 0
+    last_exception = None
+    same_exception_count = 0
+
+    print(f"[CodeSuture WATCH] Starting watch on {script} (max-restarts={max_restarts})")
+
+    while restarts <= max_restarts:
+        cmd = [sys.executable, "-m", "codesuture", "run"]
+        if shadow:
+            cmd.append("--shadow")
+        if verbose:
+            cmd.append("--verbose")
+        cmd.append(script)
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=60,
+            )
+        except subprocess.TimeoutExpired:
+            print("[CodeSuture WATCH] Script timed out.")
+            restarts += 1
+            continue
+
+        output = (result.stdout or "") + (result.stderr or "")
+        print(output, end="")
+
+        if result.returncode == 0:
+            print("[CodeSuture WATCH] Script exited cleanly.")
+            return 0
+
+        patches_applied = output.lower().count("patch applied")
+
+        current_exception = _extract_exception(output)
+        if current_exception and current_exception == last_exception and patches_applied == 0:
+            same_exception_count += 1
+        else:
+            same_exception_count = 0
+            last_exception = current_exception
+
+        if same_exception_count >= 2:  
+            print("[CodeSuture WATCH] Unrecoverable: same exception fired 3x with 0 new patches.")
+            return 1
+
+        restarts += 1
+
+        if restarts > max_restarts:
+            break
+
+        print(f"[CodeSuture WATCH] Restarting ({restarts}/{max_restarts})...")
+        time.sleep(0.5)
+
+    print(f"[CodeSuture WATCH] Max restarts ({max_restarts}) reached.")
+    return 1
+
+def _extract_exception(output):
+
+    import re
+
+    matches = re.findall(r"(?:Caught |Script exited with: )(\w+Error[:\s].*?)(?:\n|$)", output)
+    if matches:
+        return matches[-1].strip()
+
+    matches = re.findall(r"(\w+Error: .+?)(?:\n|$)", output)
+    if matches:
+        return matches[-1].strip()
+    return None

codesuture-0.5.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: codesuture
+Version: 0.5.0
+Summary: Runtime Python bytecode patcher with guard knowledge base, persistence, and self-healing re-execution
+License-Expression: MIT
+Project-URL: Source, https://github.com/codesuture-py/codesuture
+Keywords: bytecode,runtime,patching,self-healing,debugging,null-safety,resilience
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bytecode>=0.15.1
+Provides-Extra: autonomous
+Requires-Dist: llama-cpp-python; extra == "autonomous"
+Dynamic: license-file
+
+# CodeSuture
+
+> Runtime Python bytecode patcher. Catches crashes, synthesizes guards, rewrites functions in-memory, and persists fixes across runs.
+
+## What it does
+
+CodeSuture intercepts runtime exceptions in your Python program, analyzes the failing bytecode to determine the root cause, synthesizes a deterministic guard (such as a null check or bounds clamp), rewrites the function's bytecode in memory, rewinds execution to retry, and persists the fix so it loads instantly on subsequent runs. No source files are modified. It is a surgical debugging tool that turns crashes into self-healing code.
+
+## Quick start
+
+```bash
+pip install codesuture
+```
+
+```bash
+codesuture run your_buggy_script.py
+```
+
+```
+[CodeSuture] Caught AttributeError: 'NoneType' object has no attribute 'bio'
+[CodeSuture] Applying null_guard on 'profile' ...
+[CodeSuture] Patch applied to get_bio().
+[CodeSuture] Re-executing after 1 patch(es)...
+
+Session summary:
+  Patches applied: 1
+```
+
+## How it works
+
+1. **Catch** — A `sys.settrace` callback intercepts exceptions at the exact frame and instruction offset where they occur.
+2. **Analyze** — The pattern matcher disassembles the function's bytecode, identifies the failing variable/operation, and selects the appropriate guard type.
+3. **Patch** — The guard synthesizer injects new bytecode instructions (null checks, bounds clamps, safe `.get()` calls) into the function's code object. A semantic diff gate rejects patches that change too many instructions.
+4. **Rewind** — Execution restarts from the top of the patched function. The guard prevents the same crash from recurring.
+5. **Persist** — The patched code object is serialized to `.codesuture_store/` with JSON metadata. On subsequent runs, persisted patches load before the first function call.
+
+## Supported guard types
+
+| Guard type | Triggers on | Example |
+|---|---|---|
+| `null_guard` | `AttributeError` on `None` | `user.profile.bio` when `profile is None` |
+| `index_guard` | `IndexError` (list out of range) | `items[10]` when `len(items) == 2` |
+| `key_guard` | `KeyError` | `cfg["timeout"]` when key missing |
+| `type_coercion_guard` | `TypeError` (conversion failure) | `int("not_a_number")` |
+| `subscript_guard` | `TypeError` subscripting `None` | `data["key"]` when `data is None` |
+| `chain_subscript_guard` | Nested subscript on `None` | `data["user"]["name"]` |
+| `division_guard` | `ZeroDivisionError` | `x / count` when `count == 0` |
+| `str_coerce_guard` | `TypeError` (str + non-str) | `"age: " + 25` |
+| `file_guard` | `FileNotFoundError` | `open(path)` when file missing |
+| `callable_guard` | `TypeError` calling `None` | `func()` when `func is None` |
+
+## CLI reference
+
+| Command | Flags | What it does |
+|---|---|---|
+| `codesuture run <script>` | | Run script with live patching enabled |
+| `codesuture run <script>` | `--verbose` | Show patch diffs and instruction deltas |
+| `codesuture run <script>` | `--shadow` | Warn if patched functions return sentinel values |
+| `codesuture run <script>` | `--dry-run` | Show what would be patched without applying |
+| `codesuture run <script>` | `--ttl DAYS` | Set patch expiry (default: 7 days) |
+| `codesuture run <script>` | `--retries N` | Max re-execution attempts (default: 3) |
+| `codesuture audit` | | Show all active patches in a formatted table |
+| `codesuture rollback <name>` | | Remove persisted patch for one function |
+| `codesuture rollback` | `--all` | Remove ALL patches + fingerprint registry |
+| `codesuture rollback` | `--dry-run` | List what would be removed |
+
+## Dark upgrades
+
+- **D1 — Semantic diff safety gate**: Rejects patches that modify too many instructions, preventing runaway bytecode corruption.
+- **D2 — Caller-aware patch propagation**: Propagates patches to closures and bound methods via `gc.get_referrers`.
+- **D3 — Shadow execution mode**: Monitors patched function return values and warns when sentinel defaults leak downstream.
+- **D4 — Patch expiry TTL**: Warns when patches exceed their time-to-live, nudging developers to fix the root cause in source.
+- **D5 — Bytecode fingerprint registry**: Caches crash patterns by bytecode hash for instant guard selection on repeated failures.
+- **D6 — Audit command**: Displays all active patches in a formatted table with function name, guard type, age, and rollback hints.
+
+## Limitations
+
+- **Python 3.11+ only** — CodeSuture relies on `PUSH_NULL`, `PRECALL`, and `POP_JUMP_FORWARD_IF_*` opcodes introduced in CPython 3.11.
+- **Async not yet supported** — `async def` functions and coroutines are not patched.
+- **Semantic bugs not patchable** — CodeSuture fixes structural crashes (null access, missing keys, type mismatches). It cannot fix logic errors where the code runs but produces wrong results.
+- **Single-process scope** — Patches are applied per-process. Multi-process or distributed systems need separate CodeSuture instances.
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

codesuture-0.5.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+codesuture/__init__.py,sha256=LBK46heutvn3KmsCrKIYu8RQikbfnjZaj2xFrXaeCzQ,22
+codesuture/__main__.py,sha256=BbUA6Fvc9zApaO4IGe9F8meluGvNQNMOr_Cp_aq4y6k,75
+codesuture/_eval_fix.py,sha256=b7Qnx3FySkEwTjRSJmyOxPfQd5ihe5hO4KqFUa7MiW0,121
+codesuture/audit.py,sha256=tUitXsNc3LqYvcB4iDqL7IFeGUkyTrj3LZPxCW6uWdo,4376
+codesuture/cli.py,sha256=vcvQi83K1GDHqrEnDLFcIGQZ8L6nWZWaEfPt_fEwF54,6068
+codesuture/code_replacer.py,sha256=UddSbpQ-5UQIWxrES6G8WUXQkpQmECRVlvh5BXK5mZM,2797
+codesuture/codesuture_fix.py,sha256=u9-dYj8h_HsNKggRn6r0AB8wu9mofdAx-pbNLCEhUG0,3154
+codesuture/debuggee.py,sha256=gavL8h28_olmUvhJrBC8jRbxmcnNz2cu8SbA-Vxz7bo,232
+codesuture/diff_guard.py,sha256=1CWw-dIXajU4riN8PWkq5g-NEfHx03W8QmAtuDqHJ4U,972
+codesuture/explain.py,sha256=7hg-S6xhc5k55kEkAjGNOC_C3_Ik33IpIAj0n2sJTXY,5066
+codesuture/fingerprint.py,sha256=65wUsBsJ6iPMekIVkjZVDLeFVWx9uFG9cA92Y3ufIrM,1823
+codesuture/guard_synthesizer.py,sha256=xNhc9U56sv2IlbRPG48QfttVv6KC-yglVAorU-c-slQ,21295
+codesuture/knowledge.py,sha256=brZ8KWBXUq67KJUj7XE5toTB640rRhtzm9MurzK5xDo,1067
+codesuture/middleware.py,sha256=RNmHt2mayMqLzGa174IQHJpF5TV4tF7_7BHTwD74-so,2633
+codesuture/pattern_matcher.py,sha256=B1CxqiP7jE-yfiRsP80SpR7ywlTbLimAbuctfad8lvY,22105
+codesuture/persistence.py,sha256=mIJgIF1ozcI-R9-ChqDTU2UxxK61tTbNa4UOzSHQOJY,12303
+codesuture/rewind.py,sha256=U5YoGYwR2GSLQNX7j_uq-BCORazC7_E55VFrxZM6McE,1024
+codesuture/rollback.py,sha256=B2CSdZnzflxHprnl97KY-DVCoTU5xIR07_vmAtKW5mE,2658
+codesuture/sandbox.py,sha256=xuXcljY-dvRrhTPrK066B1w3ZkIt0Or-1nWWkK1Rk9M,3885
+codesuture/shadow.py,sha256=hdNj5AoINEfbvhwjaA-cp-LW2WscKvqHKOK4P915qaE,637
+codesuture/tracer.py,sha256=AfhamJV3F8PxGWWE87_eAOeWcNbOpCq3yXWP-BuG5b0,18923
+codesuture/watcher.py,sha256=UStuV2jeNW4THXPbbxEzeW-RvI2W0GPn5OHKFcl6E-c,2293
+codesuture/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codesuture/plugins/autonomous.py,sha256=i9RFUYgYwP_oeXpvJXzxRVAjICkQEpN138vvcnBNUEo,2034
+codesuture-0.5.0.dist-info/licenses/LICENSE,sha256=vIM1B2ElIJEtcTeUSgi1zL_ACNMZTHa73OfFGcy_6A0,2248
+codesuture-0.5.0.dist-info/METADATA,sha256=KzErH1nZmwxmFzoZnQHcw7kVnL7FbcSpe1dqRX4HWyM,5967
+codesuture-0.5.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codesuture-0.5.0.dist-info/entry_points.txt,sha256=0qxyKDStiJLxP_0RmZhmxHoH-8mISXvulCP2cSyMbY4,51
+codesuture-0.5.0.dist-info/top_level.txt,sha256=Hd9qfnlIMfoRq-xtdVRBBigFvJBX3Z9TY1QdD609uGw,11
+codesuture-0.5.0.dist-info/RECORD,,

codesuture-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codesuture-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codesuture = codesuture.cli:main