codesuture 0.5.0__py3-none-any.whl

codesuture/__init__.py

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

codesuture/__main__.py

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

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/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/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/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/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/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.")

codesuture/diff_guard.py

@@ -0,0 +1,27 @@
+import dis
+from dataclasses import dataclass
+
+@dataclass
+class DiffResult:
+    guard_type: str
+    added: int
+    removed: int
+    changed: int
+    allowed: int
+    rejected: bool
+    reason: str = ""
+
+def semantic_diff(original_code, patched_code, guard_type: str) -> DiffResult:
+    orig_ops  = [(i.opname, i.argval) for i in dis.get_instructions(original_code)]
+    patch_ops = [(i.opname, i.argval) for i in dis.get_instructions(patched_code)]
+    added   = len([x for x in patch_ops if x not in orig_ops])
+    removed = len([x for x in orig_ops  if x not in patch_ops])
+    changed = max(added, removed)
+    allowed = max(50, int(len(orig_ops) * 0.40))
+    rejected = changed > allowed
+    reason = (
+        f"Semantic diff too large for {guard_type}: "
+        f"{changed} instructions changed, allowed <= {allowed}. "
+        f"Patch was NOT applied."
+    ) if rejected else ""
+    return DiffResult(guard_type, added, removed, changed, allowed, rejected, reason)

codesuture/explain.py

@@ -0,0 +1,147 @@
+
+import os
+import json
+import sys
+from datetime import datetime
+
+def run_explain(func_name=None):
+
+    candidates = [
+        ".codesuture_cache", ".codesuture_store",
+        ".codesuture", "codesuture_patches",
+    ]
+    store = None
+    for c in candidates:
+        if os.path.exists(c):
+            store = c
+            break
+
+    if not store:
+        print("[CodeSuture] No active patches.")
+        return
+
+    patches = _load_all_patches(store)
+
+    if not patches:
+        print("[CodeSuture] No active patches.")
+        return
+
+    if func_name:
+        patches = [p for p in patches if func_name.lower() in p.get("func_name", "").lower()]
+        if not patches:
+            print(f"[CodeSuture] No patches found for '{func_name}'.")
+            return
+
+    now = datetime.utcnow()
+
+    try:
+        "|".encode(sys.stdout.encoding or "ascii")
+        HAS_UNICODE = True
+    except Exception:
+        HAS_UNICODE = False
+
+    col_func    = max(12, max(len(p.get("func_name", "?")) for p in patches) + 2)
+    col_guard   = max(12, max(len(p.get("guard_type", "?")) for p in patches) + 2)
+    col_target  = max(10, max(len(str(p.get("target", "?"))) for p in patches) + 2)
+    col_default = max(10, max(len(repr(p.get("default_value", "?"))[:15]) for p in patches) + 2)
+    col_age     = 12
+    col_safe    = 9
+
+    v = "|" if HAS_UNICODE else "|"
+
+    def row(f, g, t, d, a, s):
+        return (f"{v} {f:<{col_func}} {v} {g:<{col_guard}} {v} "
+                f"{t:<{col_target}} {v} {d:<{col_default}} {v} "
+                f"{a:<{col_age}} {v} {s:<{col_safe}} {v}")
+
+    if HAS_UNICODE:
+        sep = (f"+-{'-'*col_func}-+-{'-'*col_guard}-+-"
+               f"{'-'*col_target}-+-{'-'*col_default}-+-{'-'*col_age}-+-{'-'*col_safe}-+")
+        top = (f"+-{'-'*col_func}-+-{'-'*col_guard}-+-"
+               f"{'-'*col_target}-+-{'-'*col_default}-+-{'-'*col_age}-+-{'-'*col_safe}-+")
+        bot = (f"+-{'-'*col_func}-+-{'-'*col_guard}-+-"
+               f"{'-'*col_target}-+-{'-'*col_default}-+-{'-'*col_age}-+-{'-'*col_safe}-+")
+    else:
+        sep = (f"+-{'-'*col_func}-+-{'-'*col_guard}-+-"
+               f"{'-'*col_target}-+-{'-'*col_default}-+-{'-'*col_age}-+-{'-'*col_safe}-+")
+        top = sep
+        bot = sep
+
+    print()
+    print("  CodeSuture Explain - Active Patches")
+    print()
+    print(top)
+    print(row("Function", "Guard type", "Target", "Default value", "Age (days)", "Safe?"))
+    print(sep)
+
+    for p in patches:
+        func    = p.get("func_name", "?")
+        guard   = p.get("guard_type", "?")
+        target  = str(p.get("target", "?"))
+        default = repr(p.get("default_value", "?"))[:15]
+        age_str = "?"
+        if "patched_at" in p:
+            try:
+                dt = datetime.fromisoformat(p["patched_at"])
+                days = (now - dt).days
+                age_str = f"{days}d ago (patched)"
+            except Exception:
+                pass
+        safe = _assess_safety(p)
+        print(row(func, guard, target, default, age_str, safe))
+
+    print(bot)
+    print()
+    print(f"  Total: {len(patches)} active patch(es).")
+    print()
+
+def _assess_safety(patch_data):
+
+    default = patch_data.get("default_value")
+    guard_type = patch_data.get("guard_type", "")
+    target = str(patch_data.get("target", ""))
+
+    string_methods = {"strip", "upper", "lower", "title", "capitalize",
+                      "casefold", "swapcase", "encode", "replace", "split"}
+
+    is_string_downstream = any(m in target.lower() for m in string_methods)
+
+    if default == "" and (guard_type == "null_guard" or is_string_downstream):
+        return "LIKELY"
+
+    if default == 0 and is_string_downstream:
+        return "RISKY"
+
+    if default == "" and guard_type in ("null_guard", "subscript_guard", "key_guard"):
+        return "LIKELY"
+
+    return "UNKNOWN"
+
+def _load_all_patches(store_path):
+
+    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/fingerprint.py

@@ -0,0 +1,52 @@
+import hashlib
+import dis
+import json
+import os
+from datetime import datetime
+
+FINGERPRINT_FILE = ".codesuture_fingerprints"
+
+def compute_fingerprint(code_obj, crash_offset: int, exc_type_name: str) -> str:
+    instructions = list(dis.get_instructions(code_obj))
+    offsets = [i.offset for i in instructions]
+    try:
+        idx = offsets.index(crash_offset)
+    except ValueError:
+        idx = len(instructions) - 1
+    window = instructions[max(0, idx-2):idx+3]
+    key = str([(i.opname, str(i.argval)) for i in window]) + ":" + exc_type_name
+    return hashlib.sha256(key.encode()).hexdigest()[:16]
+
+def load_registry() -> dict:
+    if not os.path.exists(FINGERPRINT_FILE):
+        return {}
+    with open(FINGERPRINT_FILE, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def save_registry(registry: dict):
+    with open(FINGERPRINT_FILE, "w", encoding="utf-8") as f:
+        json.dump(registry, f, indent=2)
+
+def lookup(fingerprint: str) -> dict | None:
+    return load_registry().get(fingerprint)
+
+def record(fingerprint: str, guard_type: str, target: str,
+           func_name: str, error_type: str, default_value=None, key_name=None):
+    registry = load_registry()
+    if fingerprint not in registry:
+        registry[fingerprint] = {
+            "guard_type":  guard_type,
+            "target":      target,
+            "error_type":  error_type,
+            "default_value": default_value,
+            "key_name": key_name,
+            "first_seen":  datetime.utcnow().isoformat(),
+            "hit_count":   0,
+            "functions":   []
+        }
+    entry = registry[fingerprint]
+    entry["hit_count"] += 1
+    if func_name not in entry["functions"]:
+        entry["functions"].append(func_name)
+    save_registry(registry)
+    return entry