codesuture 0.5.0__tar.gz

codesuture-0.5.0/LICENSE

@@ -0,0 +1,33 @@
+<<<<<<< HEAD
+
+
+Copyright <2026> <MUHAMMAD ABUBAKAR>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=======
+MIT License
+
+Copyright (c) 2026 MUHAMMAD ABUBAKAR
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+>>>>>>> 354c8c39be3e4e36096d5b2725b1828a0d53729f

codesuture-0.5.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,85 @@
+# 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/codesuture/__init__.py

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

codesuture-0.5.0/codesuture/__main__.py

@@ -0,0 +1,5 @@
+
+from codesuture.cli import main
+
+if __name__ == "__main__":
+    main()

codesuture-0.5.0/codesuture/_eval_fix.py

@@ -0,0 +1,5 @@
+import sys
+from codesuture.codesuture_fix import apply_fix_with_info
+
+result = apply_fix_with_info()
+print(result)   

codesuture-0.5.0/codesuture/audit.py

@@ -0,0 +1,127 @@
+import os
+import json
+import sys
+from datetime import datetime
+
+def run_audit(patch_store_path: str = None):
+
+    candidates = [
+        ".codesuture_cache", ".codesuture_store",
+        ".codesuture", "codesuture_patches"
+    ]
+    store = patch_store_path
+    if not store:
+        for c in candidates:
+            if os.path.exists(c):
+                store = c
+                break
+
+    if not store:
+        print("[CodeSuture] No patch store found. Nothing has been patched yet.")
+        return
+
+    patches = _load_all_patches(store)
+
+    if not patches:
+        print("[CodeSuture] Patch store exists but is empty.")
+        return
+
+    now = datetime.utcnow()
+
+    col_func    = max(18, max(len(p.get("func_name","?")) for p in patches) + 2)
+    col_guard   = 12
+    col_target  = 10
+    col_default = 10
+    col_age     = 7
+
+    try:
+        "|".encode(sys.stdout.encoding or 'ascii')
+        HAS_UNICODE = True
+    except Exception:
+        HAS_UNICODE = False
+
+    def row(f, g, t, d, a):
+        v = "|" if HAS_UNICODE else "|"
+        return (f"{v} {f:<{col_func}} {v} {g:<{col_guard}} {v} "
+                f"{t:<{col_target}} {v} {d:<{col_default}} {v} {a:<{col_age}} {v}")
+
+    if HAS_UNICODE:
+        sep = (f"+-{'-'*col_func}-+-{'-'*col_guard}-+-"
+               f"{'-'*col_target}-+-{'-'*col_default}-+-{'-'*col_age}-+")
+        top = (f"+-{'-'*col_func}-+-{'-'*col_guard}-+-"
+               f"{'-'*col_target}-+-{'-'*col_default}-+-{'-'*col_age}-+++")
+        bot = (f"+-{'-'*col_func}-+-{'-'*col_guard}-+-"
+               f"{'-'*col_target}-+-{'-'*col_default}-+-{'-'*col_age}-+")
+    else:
+        sep = (f"|-{'*'*col_func}-+-{'*'*col_guard}-+-"
+               f"{'*'*col_target}-+-{'*'*col_default}-+-{'*'*col_age}-|")
+        top = sep
+        bot = sep
+
+    print()
+    print("  CodeSuture Audit Report")
+    print()
+    print(top)
+    print(row("Function", "Guard", "Target", "Default", "Age"))
+    print(sep)
+
+    oldest_days = 0
+    expired = 0
+    for p in patches:
+        func    = p.get("func_name", "?")
+        guard   = p.get("guard_type", "?")
+        target  = p.get("target",     "?")
+        default = repr(p.get("default_value", "?"))[:col_default]
+        age_str = "?"
+        ttl_days = p.get("ttl_days", 7)
+        if "patched_at" in p:
+            try:
+                dt = datetime.fromisoformat(p["patched_at"])
+                days = (now - dt).days
+                oldest_days = max(oldest_days, days)
+                age_str = f"{days}d"
+                if days > ttl_days:
+                    age_str += " [WARN]"
+                    expired += 1
+            except Exception:
+                pass
+        print(row(func, guard, target, default, age_str))
+
+    print(bot)
+    print()
+    print(f"  Total: {len(patches)} active patch(es). "
+          f"Oldest: {oldest_days}d. "
+          f"{'[WARN] ' + str(expired) + ' expired - run codesuture rollback to clear.' if expired else 'All within TTL.'}")
+    print()
+    print("  Run 'codesuture rollback <function_name>' to remove a patch.")
+    print("  Run 'codesuture rollback --all' to clear everything.")
+    print()
+
+def _load_all_patches(store_path: str) -> list[dict]:
+
+    patches = []
+    if os.path.isdir(store_path):
+        for root, dirs, files in os.walk(store_path):
+            for fname in files:
+                fpath = os.path.join(root, fname)
+                if fname.endswith(".json") and os.path.isfile(fpath):
+                    try:
+                        with open(fpath, "r", encoding="utf-8") as f:
+                            data = json.load(f)
+                            if isinstance(data, list):
+                                patches.extend(data)
+                            elif isinstance(data, dict):
+                                patches.append(data)
+                    except Exception:
+                        pass
+    elif os.path.isfile(store_path):
+        try:
+            with open(store_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, list):
+                    patches = data
+                elif isinstance(data, dict):
+                    patches = list(data.values())
+        except Exception:
+            pass
+    return patches

codesuture-0.5.0/codesuture/cli.py

@@ -0,0 +1,127 @@
+import sys
+import argparse
+from codesuture.tracer import install, uninstall
+
+def main():
+    parser = argparse.ArgumentParser(prog='codesuture',
+                                     description='Runtime Python bytecode patcher with self-healing re-execution')
+    parser.add_argument('--version', action='version', version='codesuture 0.5.0')
+    sub = parser.add_subparsers(dest='command', required=True)
+
+    run_parser = sub.add_parser('run', help='Run a script with live patching')
+    run_parser.add_argument('script', help='Target script to run')
+    run_parser.add_argument('--dry-run', action='store_true', help='Show what would be patched without applying')
+    run_parser.add_argument('--log', metavar='FILE', help='Append patch events (JSON lines) to FILE')
+    run_parser.add_argument('--retries', type=int, default=3, metavar='N', help='Max patching attempts (default: 3)')
+    run_parser.add_argument('--self-test', action='store_true', help='Corrupt the engine to test self-healing')
+    run_parser.add_argument('--autonomous', action='store_true', help='Enable autonomous LLM bug-fixing')
+    run_parser.add_argument('--verbose', action='store_true', help='Show detailed debug output')
+    run_parser.add_argument('--shadow', action='store_true', help='Warn if patched functions return sentinel values')
+    run_parser.add_argument('--ttl', type=int, default=7, metavar='DAYS', help='Patch TTL in days (default: 7)')
+
+    sub.add_parser('audit', help='Show all active patches')
+
+    rb_parser = sub.add_parser('rollback', help='Remove persisted patches')
+    rb_parser.add_argument('function_name', nargs='?', default=None, help='Function name to roll back')
+    rb_parser.add_argument('--all', action='store_true', dest='rollback_all', help='Remove ALL patches + fingerprints')
+    rb_parser.add_argument('--dry-run', action='store_true', dest='rollback_dry_run', help='List what would be removed')
+
+    watch_parser = sub.add_parser('watch', help='Watch and auto-restart a script with live patching')
+    watch_parser.add_argument('script', help='Target script to watch')
+    watch_parser.add_argument('--max-restarts', type=int, default=10, metavar='N',
+                              help='Maximum number of restarts (default: 10)')
+    watch_parser.add_argument('--shadow', action='store_true', help='Enable shadow mode warnings')
+    watch_parser.add_argument('--verbose', action='store_true', help='Show detailed debug output')
+
+    explain_parser = sub.add_parser('explain', help='Show detailed explanation of active patches')
+    explain_parser.add_argument('func_name', nargs='?', default=None, help='Function name to explain')
+
+    args = parser.parse_args()
+
+    if args.command == 'audit':
+        from codesuture.audit import run_audit
+        run_audit()
+        return
+
+    if args.command == 'rollback':
+        from codesuture.rollback import rollback_function, rollback_all, rollback_dry_run
+        if args.rollback_dry_run:
+            rollback_dry_run()
+        elif args.rollback_all:
+            rollback_all()
+        elif args.function_name:
+            rollback_function(args.function_name)
+        else:
+            print("[CodeSuture] Usage: codesuture rollback <function_name> | --all | --dry-run")
+        return
+
+    if args.command == 'watch':
+        from codesuture.watcher import watch
+        exit_code = watch(
+            args.script,
+            max_restarts=args.max_restarts,
+            shadow=args.shadow,
+            verbose=args.verbose,
+        )
+        sys.exit(exit_code)
+
+    if args.command == 'explain':
+        from codesuture.explain import run_explain
+        run_explain(args.func_name)
+        return
+
+    if getattr(args, 'autonomous', False):
+        try:
+            import llama_cpp
+        except ImportError:
+            print("Autonomous mode requires llama-cpp-python. Install with: pip install codesuture[autonomous]")
+            sys.exit(1)
+
+    if args.command == 'run':
+        from codesuture.persistence import install_import_hook, make_persisted_patch_globals
+
+        install_import_hook()
+
+        if getattr(args, 'self_test', False):
+            import codesuture.pattern_matcher as pm
+            print("[CodeSuture] SELF-TEST: corrupting _infer_default -> None")
+            pm._infer_default = None
+        tracer = None
+        try:
+            with open(args.script, 'r', encoding='utf-8') as f:
+                source = f.read()
+            code = compile(source, args.script, 'exec')
+
+            tracer = install(dry_run=args.dry_run, log_file=args.log,
+                             max_retries=args.retries,
+                             autonomous=getattr(args, 'autonomous', False),
+                             script_path=args.script, verbose=args.verbose,
+                             shadow=args.shadow, ttl=args.ttl)
+            max_runs = args.retries + 1
+            for run in range(max_runs):
+                patched_before = tracer.stats['patched']
+                tracer._handled_exc_ids.clear()
+                try:
+                    sys.settrace(tracer)
+                    globs = make_persisted_patch_globals(
+                        "__main__",
+                        {'__name__': '__main__', '__file__': args.script},
+                    )
+                    exec(code, globs)
+                    break
+                except Exception as e:
+                    sys.settrace(None)
+                    new_patches = tracer.stats['patched'] - patched_before
+                    if new_patches > 0 and run < max_runs - 1:
+                        print(f"[CodeSuture] Re-executing after {new_patches} patch(es)...")
+                        continue
+                    else:
+                        print(f"[CodeSuture] Script exited with: {e}")
+                        break
+        finally:
+            uninstall()
+            if tracer is not None:
+                tracer.report()
+
+if __name__ == '__main__':
+    main()

codesuture-0.5.0/codesuture/code_replacer.py

@@ -0,0 +1,82 @@
+import types
+import inspect
+
+def replace_function_code(func, new_code):
+
+    from codesuture.guard_synthesizer import propagate_patch
+    propagate_patch(func, new_code)
+
+def get_function_from_frame(frame):
+    name = frame.f_code.co_name
+    code = frame.f_code
+
+    if name in frame.f_locals:
+        candidate = frame.f_locals[name]
+        if hasattr(candidate, '__code__') and candidate.__code__ is code:
+            return candidate
+
+    if name in frame.f_globals:
+        candidate = frame.f_globals[name]
+        if hasattr(candidate, '__code__') and candidate.__code__ is code:
+            return candidate
+
+    if name == '<module>':
+        return None
+
+    self_obj = frame.f_locals.get('self')
+    if self_obj is not None:
+        cls = type(self_obj)
+        method = getattr(cls, name, None)
+        if method is not None:
+            if isinstance(method, property) and method.fget is not None:
+                func = method.fget
+            else:
+                func = method
+            if hasattr(func, '__func__'):
+                func = func.__func__
+            if hasattr(func, '__code__') and func.__code__ is code:
+                return func
+
+    cls_obj = frame.f_locals.get('cls')
+    if cls_obj is not None and isinstance(cls_obj, type):
+        method = getattr(cls_obj, name, None)
+        if method is not None:
+            if isinstance(method, property) and method.fget is not None:
+                func = method.fget
+            else:
+                func = method
+            if hasattr(func, '__func__'):
+                func = func.__func__
+            if hasattr(func, '__code__') and func.__code__ is code:
+                return func
+
+    for val in frame.f_globals.values():
+        if isinstance(val, type):
+            method = getattr(val, name, None)
+            if method is not None:
+                if isinstance(method, property) and method.fget is not None:
+                    func = method.fget
+                else:
+                    func = method
+                if hasattr(func, '__func__'):
+                    func = func.__func__
+                if hasattr(func, '__code__') and func.__code__ is code:
+                    return func
+
+    for val in frame.f_globals.values():
+        if hasattr(val, '__wrapped__'):
+            inner = val.__wrapped__
+            if hasattr(inner, '__code__') and inner.__code__ is code:
+                return inner
+        if hasattr(val, '__code__') and val.__code__ is code:
+            return val
+
+    return None
+
+def get_source_from_frame(frame):
+
+    func = get_function_from_frame(frame)
+    try:
+        return inspect.getsource(func)
+    except Exception as e:
+        return f"# Could not get source: {e}\n"

codesuture-0.5.0/codesuture/codesuture_fix.py

@@ -0,0 +1,85 @@
+import sys
+import inspect
+import os
+import types
+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
+
+def apply_fix(exc_type_name: str = None, exc_msg: str = None) -> str:
+
+    exc_info = sys.exc_info()
+    target_frame = None
+    tb = None
+
+    if exc_info[0] is not None:
+        if exc_type_name is None:
+            exc_type_name = exc_info[0].__name__
+        if exc_msg is None:
+            exc_msg = str(exc_info[1])
+
+        tb = exc_info[2]
+        curr_tb = tb
+        while curr_tb and curr_tb.tb_next:
+            curr_tb = curr_tb.tb_next
+        if curr_tb:
+            target_frame = curr_tb.tb_frame
+
+    if target_frame is None:
+        if exc_type_name is None or exc_msg is None:
+            return "ERROR: No active exception. You must provide exc_type_name and exc_msg if paused on an unhandled exception."
+
+        for fi in inspect.stack():
+            frame = fi.frame
+            filename = frame.f_code.co_filename
+            func_name = frame.f_code.co_name
+
+            if 'pydevd' in filename.lower() and func_name in ('evaluate_expression', 'new_func', '_run_with_unblock_threads', '_run_with_interrupt_thread'):
+                potential_frame = frame.f_locals.get('frame')
+                if isinstance(potential_frame, types.FrameType):
+                    target_frame = potential_frame
+                    break
+
+            if func_name in ('apply_fix', 'apply_fix_with_info', '<module>', 'Exec', 'exec'):
+                continue
+            if any(x in filename.lower() for x in ('pydevd', 'debugpy', 'threading', 'importlib')):
+                continue
+
+            basename = os.path.basename(filename)
+            internal_files = (
+                'codesuture_fix.py', 'pattern_matcher.py', 'guard_synthesizer.py',
+                'code_replacer.py', 'rewind.py', 'tracer.py', 'debuggee.py'
+            )
+            if basename in internal_files:
+                continue
+
+            target_frame = frame
+            break
+
+    if target_frame is None:
+        return "ERROR: No paused frame found"
+
+    class FakeExc:
+        def __init__(self, msg):
+            self._msg = msg
+        def __str__(self):
+            return self._msg
+
+    exc_type = FakeExc
+    exc_type.__name__ = exc_type_name
+    exc_value = FakeExc(exc_msg)
+
+    spec = analyze_exception(target_frame, exc_type, exc_value, tb)
+    if spec is None:
+        return f"ERROR: No deterministic patch for {exc_type_name}"
+
+    try:
+        func = get_function_from_frame(target_frame)
+        new_bc = synthesize_guarded_code(target_frame.f_code, spec)
+        new_code = new_bc.to_code()
+        replace_function_code(func, new_code)
+        rewind_frame_to_start(target_frame, target_frame.f_code)
+        return f"OK: patched {target_frame.f_code.co_name} ({spec.strategy} on {spec.var_name})"
+    except Exception as e:
+        return f"ERROR: {e}"

codesuture-0.5.0/codesuture/debuggee.py

@@ -0,0 +1,7 @@
+import debugpy
+
+def enable(port=5678):
+    debugpy.listen(port)
+    print(f"[CodeSuture] Waiting for debugger on port {port}...")
+    debugpy.wait_for_client()
+    print("[CodeSuture] Debugger attached. Live patching active.")