codesuture 0.5.0__py3-none-any.whl

codesuture/persistence.py

@@ -0,0 +1,330 @@
+import os
+import marshal
+import sys
+import importlib.abc
+import inspect
+import json
+from datetime import datetime
+import threading
+
+CACHE_DIR = ".codesuture_store"
+HEALED_FUNCTIONS = set()
+ANNOUNCED_HEALED_FUNCTIONS = set()
+_store_lock = threading.Lock()
+
+def _heal_key(module_name, func_name, key_name=None):
+
+    base = f"{module_name}.{func_name}"
+    if key_name:
+        return f"{base}:{key_name}"
+    return base
+
+def save_patch(func, new_code, spec=None, ttl_days=7):
+    module_name = getattr(func, '__module__', None)
+    if not module_name:
+        return
+    func_name = getattr(func, '__qualname__', func.__name__)
+    func_name = func_name.replace('<', '_').replace('>', '_')
+
+    os.makedirs(CACHE_DIR, exist_ok=True)
+
+    base_name = f"{module_name}.{func_name}"
+    cache_path = os.path.join(CACHE_DIR, f"{base_name}.code")
+    json_path = os.path.join(CACHE_DIR, f"{base_name}.json")
+
+    with _store_lock:
+        with open(cache_path, "wb") as f:
+            marshal.dump(new_code, f)
+
+    if spec is not None:
+        target_name = spec.var_name
+        if spec.strategy == 'null_guard' and spec.key_name:
+            target_name = spec.key_name[-1] if isinstance(spec.key_name, tuple) else spec.key_name
+
+        metadata = {
+            "func_name": func_name,
+            "guard_type": spec.strategy,
+            "target": target_name,
+            "default_value": spec.default_value,
+            "patched_at": datetime.utcnow().isoformat(),
+            "ttl_days": ttl_days
+        }
+        metadata["thread"] = "MainThread"
+        with _store_lock:
+            with open(json_path, "w", encoding="utf-8") as f:
+                json.dump(metadata, f, indent=2)
+
+def _announce_healed(module_name, func_name, key_name=None):
+    key = _heal_key(module_name, func_name, key_name)
+    if key in ANNOUNCED_HEALED_FUNCTIONS:
+        return
+    ANNOUNCED_HEALED_FUNCTIONS.add(key)
+    if key_name:
+        print(f"[CodeSuture] Already healed, skipping: loaded persistent patch for {module_name}.{func_name} ({key_name})")
+    else:
+        print(f"[CodeSuture] Already healed, skipping: loaded persistent patch for {module_name}.{func_name}")
+
+def _load_cached_code(module_name, func_name):
+    func_name = func_name.replace('<', '_').replace('>', '_')
+    if not os.path.isdir(CACHE_DIR):
+        return None
+
+    base_name = f"{module_name}.{func_name}"
+    code_path = os.path.join(CACHE_DIR, f"{base_name}.code")
+    json_path = os.path.join(CACHE_DIR, f"{base_name}.json")
+    if not os.path.isfile(code_path):
+        return None
+
+    if os.path.isfile(json_path):
+        try:
+            with open(json_path, "r", encoding="utf-8") as f:
+                patch_data = json.load(f)
+            patched_at = datetime.fromisoformat(patch_data["patched_at"])
+            ttl_days = patch_data.get("ttl_days", 7)
+            age_days = (datetime.utcnow() - patched_at).days
+            if age_days > ttl_days:
+                print(
+                    f"[CodeSuture] [WARN]  Patch for '{patch_data.get('func_name', func_name)}' "
+                    f"is {age_days} day(s) old (TTL={ttl_days}d). "
+                    f"Verify root cause is fixed in source. "
+                    f"Run 'codesuture audit' to review all patches."
+                )
+        except Exception:
+            pass
+
+    with open(code_path, "rb") as f:
+        return marshal.load(f)
+
+def _load_learned_code(func, func_name):
+    from codesuture.knowledge import load_learned_rules
+
+    for rule in load_learned_rules():
+        if rule["func_name"] != func_name:
+            continue
+
+        from codesuture.guard_synthesizer import synthesize_guarded_code
+        from codesuture.pattern_matcher import PatchSpec
+
+        spec = PatchSpec(
+            strategy='autonomous_rule',
+            var_name=func_name,
+            default_value=rule["new_source"],
+        )
+        new_bc = synthesize_guarded_code(func.__code__, spec)
+        return new_bc.to_code()
+    return None
+
+def apply_persisted_patch_to_function(func, module_name=None, func_name=None, key_name=None, announce=True):
+
+    module_name = module_name or getattr(func, '__module__', None)
+    func_name = func_name or getattr(func, '__qualname__', getattr(func, '__name__', None))
+    if not module_name or not func_name:
+        return False
+
+    new_code = _load_cached_code(module_name, func_name)
+    if new_code is None:
+        try:
+            new_code = _load_learned_code(func, func_name)
+        except Exception:
+            new_code = None
+    if new_code is None:
+        return False
+
+    from codesuture.code_replacer import replace_function_code
+
+    replace_function_code(func, new_code)
+    HEALED_FUNCTIONS.add(_heal_key(module_name, func_name, key_name))
+    if announce:
+        _announce_healed(module_name, func_name, key_name)
+    return True
+
+def _iter_cached_function_names(module_name):
+    if not os.path.isdir(CACHE_DIR):
+        return
+    prefix = f"{module_name}."
+    for filename in os.listdir(CACHE_DIR):
+        if filename.startswith(prefix) and filename.endswith(".code"):
+            yield filename[len(prefix):-5]
+
+def _resolve_attr(root, dotted_name):
+    obj = root
+    for part in dotted_name.split('.'):
+        obj = getattr(obj, part)
+    return obj
+
+def apply_persisted_patch_to_value(module_name, binding_name, value):
+    if hasattr(value, '__wrapped__'):
+        value = getattr(value, '__wrapped__')
+    if inspect.isfunction(value):
+        return apply_persisted_patch_to_function(value, module_name=module_name)
+
+    applied = False
+    if inspect.isclass(value):
+        prefix = f"{binding_name}."
+        for func_name in _iter_cached_function_names(module_name) or ():
+            if not func_name.startswith(prefix):
+                continue
+            try:
+                target = _resolve_attr(value, func_name[len(prefix):])
+                if isinstance(target, property) and target.fget is not None:
+                    target = target.fget
+                if inspect.ismethod(target):
+                    target = target.__func__
+                if hasattr(target, '__wrapped__'):
+                    target = getattr(target, '__wrapped__')
+                if inspect.isfunction(target):
+                    applied = apply_persisted_patch_to_function(
+                        target,
+                        module_name=module_name,
+                        func_name=func_name,
+                    ) or applied
+            except Exception:
+                continue
+    return applied
+
+class CodeSutureGlobals(dict):
+    def __init__(self, module_name, initial=None):
+        super().__init__()
+        self._codesuture_module_name = module_name
+        if initial:
+            for key, value in initial.items():
+                dict.__setitem__(self, key, value)
+
+    def __setitem__(self, key, value):
+        dict.__setitem__(self, key, value)
+        tracer = sys.gettrace()
+        sys.settrace(None)
+        try:
+            apply_persisted_patch_to_value(self._codesuture_module_name, key, value)
+        except Exception:
+            pass
+        finally:
+            sys.settrace(tracer)
+
+def make_persisted_patch_globals(module_name, initial=None):
+    return CodeSutureGlobals(module_name, initial)
+
+def apply_persisted_patches(module):
+    module_name = getattr(module, '__name__', None)
+    if not module_name:
+        return
+
+    for func_name in _iter_cached_function_names(module_name) or ():
+        try:
+            obj = _resolve_attr(module, func_name)
+            if isinstance(obj, property) and obj.fget is not None:
+                obj = obj.fget
+            if inspect.ismethod(obj):
+                obj = obj.__func__
+            if hasattr(obj, '__wrapped__'):
+                obj = getattr(obj, '__wrapped__')
+            if inspect.isfunction(obj):
+                apply_persisted_patch_to_function(obj, module_name, func_name)
+        except Exception:
+            pass
+
+    from codesuture.knowledge import load_learned_rules
+    rules = load_learned_rules()
+    for rule in rules:
+        func_name = rule["func_name"]
+
+        parts = func_name.split('.')
+        obj = module
+        try:
+            for part in parts:
+                obj = getattr(obj, part)
+
+            if _heal_key(module_name, func_name) in HEALED_FUNCTIONS:
+                continue
+
+            if isinstance(obj, property) and obj.fget is not None:
+                obj = obj.fget
+            if inspect.ismethod(obj):
+                obj = obj.__func__
+            if hasattr(obj, '__wrapped__'):
+                obj = getattr(obj, '__wrapped__')
+            if inspect.isfunction(obj):
+                apply_persisted_patch_to_function(obj, module_name, func_name)
+        except Exception:
+            continue
+
+class CodeSutureLoaderWrapper(importlib.abc.Loader):
+    def __init__(self, loader):
+        self.loader = loader
+
+    def create_module(self, spec):
+        if hasattr(self.loader, 'create_module'):
+            return self.loader.create_module(spec)
+        return None
+
+    def exec_module(self, module):
+        self.loader.exec_module(module)
+        apply_persisted_patches(module)
+
+    def __getattr__(self, name):
+        return getattr(self.loader, name)
+
+class CodeSutureMetaFinder(importlib.abc.MetaPathFinder):
+    def find_spec(self, fullname, path, target=None):
+        if hasattr(self, '_inside'): return None
+        self._inside = True
+        try:
+            for finder in sys.meta_path:
+                if finder is self: continue
+                if hasattr(finder, 'find_spec'):
+                    spec = finder.find_spec(fullname, path, target)
+                    if spec is not None and getattr(spec, 'loader', None) is not None:
+                        if not isinstance(spec.loader, CodeSutureLoaderWrapper):
+                            spec.loader = CodeSutureLoaderWrapper(spec.loader)
+                        return spec
+        finally:
+            delattr(self, '_inside')
+        return None
+
+def install_import_hook():
+    if not any(isinstance(f, CodeSutureMetaFinder) for f in sys.meta_path):
+        sys.meta_path.insert(0, CodeSutureMetaFinder())
+
+    for module_name, module in list(sys.modules.items()):
+        if module is not None:
+            apply_persisted_patches(module)
+
+def patch_script_code(code_obj, module_name="__main__"):
+    if not os.path.isdir(CACHE_DIR):
+        return code_obj
+
+    new_consts = list(code_obj.co_consts)
+    changed = False
+    for i, const in enumerate(new_consts):
+        if type(const).__name__ == 'code':
+            func_name = const.co_name
+            base_name = f"{module_name}.{func_name}"
+            code_path = os.path.join(CACHE_DIR, f"{base_name}.code")
+            new_code = None
+            if os.path.isfile(code_path):
+                with open(code_path, "rb") as f:
+                    new_code = marshal.load(f)
+            else:
+
+                from codesuture.knowledge import load_learned_rules
+                rules = load_learned_rules()
+                for rule in rules:
+                    if rule["func_name"] == func_name:
+                        from codesuture.guard_synthesizer import synthesize_guarded_code
+                        from codesuture.pattern_matcher import PatchSpec
+                        spec = PatchSpec(strategy='autonomous_rule', var_name=func_name, default_value=rule["new_source"])
+                        try:
+                            new_bc = synthesize_guarded_code(const, spec)
+                            new_code = new_bc.to_code()
+                        except Exception:
+                            continue
+                        break
+
+            if new_code:
+                new_consts[i] = new_code
+                changed = True
+                HEALED_FUNCTIONS.add(_heal_key(module_name, func_name))
+                _announce_healed(module_name, func_name)
+    if changed:
+        return code_obj.replace(co_consts=tuple(new_consts))
+    return code_obj

codesuture/plugins/autonomous.py

@@ -0,0 +1,64 @@
+import os
+import re
+
+_llm = None
+
+def get_llm():
+    global _llm
+    if _llm is not None:
+        return _llm
+
+    from llama_cpp import Llama
+    model_path = os.environ.get("CODESUTURE_MODEL_PATH")
+    if not model_path or not os.path.exists(model_path):
+        raise FileNotFoundError(f"LLM model not found at {model_path}. Please download a model and set CODESUTURE_MODEL_PATH environment variable.")
+
+    print("[CodeSuture] Loading local LLM... this may take a moment.")
+    _llm = Llama(
+        model_path=model_path,
+        n_ctx=2048,
+        verbose=False
+    )
+    return _llm
+
+def propose_fix(traceback_text, function_source, exc_type_name, exc_value):
+    llm = get_llm()
+
+    prompt = f"""<|system|>
+You are an expert Python developer fixing bugs autonomously.
+You are given the source code of a function that crashed, and the exception traceback.
+Your task is to rewrite the ENTIRE function to safely handle the exception. You MUST modify the code inside the function to fix the error. The easiest way is to wrap the failing code in a try/except block and return a fallback value (like 0 or None), or to use an if-statement to check the inputs. Do NOT return the original crashing code. Do NOT output code outside of the function.
+</s>
+<|user|>
+The function crashed with this error:
+{exc_type_name}: {exc_value}
+
+Original Source Code:
+```python
+{function_source}
+```
+
+Rewrite the ENTIRE function to fix this error. Output ONLY the valid python code block.
+</s>
+<|assistant|>
+```python
+"""
+
+    print("[CodeSuture] Asking LLM for a fix...")
+    response = llm(
+        prompt,
+        max_tokens=512,
+        stop=["```\n", "</s>"],
+        temperature=0.2
+    )
+
+    output = response['choices'][0]['text']
+
+    if "```python" in output:
+        output = output.split("```python")[1]
+    if "```" in output:
+        output = output.split("```")[0]
+
+    output = output.strip()
+    print(f"\n[CodeSuture] LLM Proposed Fix:\n{output}\n")
+    return output

codesuture/rewind.py

@@ -0,0 +1,43 @@
+"""
+codesuture/rewind.py
+Low‑level frame manipulation using ctypes.
+"""
+import ctypes
+import sys
+
+class PyObject(ctypes.Structure):
+    _fields_ = [
+        ("ob_refcnt", ctypes.c_ssize_t),
+        ("ob_type", ctypes.c_void_p),
+    ]
+
+class PyVarObject(PyObject):
+    _fields_ = [
+        ("ob_size", ctypes.c_ssize_t),
+    ]
+
+class PyFrameObject(PyVarObject):
+
+    _fields_ = [
+        ("f_back", ctypes.c_void_p),
+        ("f_code", ctypes.c_void_p),
+        ("f_builtins", ctypes.c_void_p),
+        ("f_globals", ctypes.c_void_p),
+        ("f_locals", ctypes.c_void_p),
+        ("f_valuestack", ctypes.c_void_p),
+        ("f_stacktop", ctypes.c_void_p),
+        ("f_lasti", ctypes.c_int),
+        ("f_lineno", ctypes.c_int),
+
+    ]
+
+def _cast_frame(frame):
+
+    return ctypes.cast(id(frame), ctypes.POINTER(PyFrameObject))
+
+def rewind_frame_to_start(frame, code):
+
+    cf = _cast_frame(frame)
+
+    cf.contents.f_lasti = -1
+    cf.contents.f_lineno = code.co_firstlineno

codesuture/rollback.py

@@ -0,0 +1,85 @@
+
+import os
+import json
+import shutil
+from datetime import datetime
+
+from codesuture.persistence import CACHE_DIR
+
+def rollback_function(name):
+
+    if not os.path.isdir(CACHE_DIR):
+        print("[CodeSuture] Nothing to roll back.")
+        return
+
+    removed = 0
+    for fname in list(os.listdir(CACHE_DIR)):
+
+        base = fname.rsplit(".", 1)[0]  
+        func_part = base.split(".", 1)[-1] if "." in base else base
+
+        if func_part == name or base == name or func_part.endswith(name):
+            path = os.path.join(CACHE_DIR, fname)
+            os.remove(path)
+            removed += 1
+
+    if removed > 0:
+        print(f"[CodeSuture] Rolled back patch for '{name}'. "
+              f"Run your script again to re-patch if needed.")
+    else:
+        print(f"[CodeSuture] No patch found matching '{name}'.")
+
+def rollback_all():
+
+    count = 0
+    if os.path.isdir(CACHE_DIR):
+        count = len(os.listdir(CACHE_DIR))
+        if count == 0:
+            print("[CodeSuture] Nothing to roll back.")
+            return
+        shutil.rmtree(CACHE_DIR)
+    else:
+        print("[CodeSuture] Nothing to roll back.")
+        return
+
+    fp = ".codesuture_fingerprints"
+    if os.path.isfile(fp):
+        os.remove(fp)
+
+    print(f"[CodeSuture] Cleared {count} patch file(s) and fingerprint registry.")
+
+def rollback_dry_run():
+
+    if not os.path.isdir(CACHE_DIR):
+        print("[CodeSuture] Nothing to roll back. Store does not exist.")
+        return
+
+    json_files = [f for f in os.listdir(CACHE_DIR) if f.endswith(".json")]
+    if not json_files:
+        print("[CodeSuture] Nothing to roll back. No patches found.")
+        return
+
+    now = datetime.utcnow()
+    print()
+    print("  [CodeSuture DRY-RUN] Would remove the following patches:")
+    print()
+    for jf in json_files:
+        path = os.path.join(CACHE_DIR, jf)
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            func = data.get("func_name", "?")
+            guard = data.get("guard_type", "?")
+            age = "?"
+            if "patched_at" in data:
+                dt = datetime.fromisoformat(data["patched_at"])
+                age = f"{(now - dt).days}d"
+            print(f"    - {func}  guard={guard}  age={age}")
+        except Exception:
+            print(f"    - {jf}  (could not read metadata)")
+
+    fp = ".codesuture_fingerprints"
+    if os.path.isfile(fp):
+        print(f"    - .codesuture_fingerprints (fingerprint registry)")
+    print()
+    print("  Run 'codesuture rollback --all' to actually remove them.")

codesuture/sandbox.py

@@ -0,0 +1,105 @@
+import subprocess
+import sys
+import os
+import tempfile
+
+def test_fix(original_script_path, module_name, func_name, new_source, exc_type_name):
+    print(f"[CodeSuture Sandbox] Testing fix for {module_name}.{func_name}...")
+
+    with tempfile.NamedTemporaryFile("w", delete=False, suffix=".py", encoding='utf-8') as f:
+        f.write(new_source)
+        source_path = f.name
+
+    with tempfile.NamedTemporaryFile("w", delete=False, suffix=".py", encoding='utf-8') as f:
+        runner_code = f"""
+import sys
+import importlib
+
+def main():
+    with open({repr(source_path)}, 'r', encoding='utf-8') as f:
+        new_source = f.read()
+
+    new_module_code = compile(new_source, "<sandbox>", 'exec')
+    new_func_code = None
+    for const in new_module_code.co_consts:
+        if type(const).__name__ == 'code' and const.co_name == {repr(func_name)}:
+            new_func_code = const
+            break
+
+    if not new_func_code:
+        print("SANDBOX ERROR: Could not find function in compiled new source")
+        sys.exit(1)
+
+    if {repr(module_name)} != '__main__':
+        from codesuture.code_replacer import replace_function_code
+        mod = importlib.import_module({repr(module_name)})
+        # Find the function object inside the module
+        parts = {repr(func_name)}.split('.')
+        obj = mod
+        for part in parts:
+            obj = getattr(obj, part)
+        replace_function_code(obj, new_func_code)
+
+        # Now run the script
+        with open({repr(original_script_path)}, 'r', encoding='utf-8') as script_file:
+            source = script_file.read()
+        code = compile(source, {repr(original_script_path)}, 'exec')
+        globs = {{'__name__': '__main__', '__file__': {repr(original_script_path)}}}
+        try:
+            exec(code, globs)
+        except Exception as e:
+            print(f"SANDBOX EXCEPTION: {{type(e).__name__}}")
+            sys.exit(1)
+    else:
+        # Patching __main__ script
+        with open({repr(original_script_path)}, 'r', encoding='utf-8') as script_file:
+            source = script_file.read()
+        code = compile(source, {repr(original_script_path)}, 'exec')
+
+        new_consts = list(code.co_consts)
+        for i, const in enumerate(new_consts):
+            if type(const).__name__ == 'code' and const.co_name == {repr(func_name)}:
+                new_consts[i] = new_func_code
+                break
+        code = code.replace(co_consts=tuple(new_consts))
+
+        globs = {{'__name__': '__main__', '__file__': {repr(original_script_path)}}}
+        try:
+            exec(code, globs)
+        except Exception as e:
+            print(f"SANDBOX EXCEPTION: {{type(e).__name__}}")
+            sys.exit(1)
+
+if __name__ == '__main__':
+    main()
+"""
+        f.write(runner_code)
+        runner_path = f.name
+
+    try:
+        result = subprocess.run(
+            [sys.executable, runner_path],
+            capture_output=True,
+            text=True,
+            timeout=3
+        )
+        output = result.stdout + result.stderr
+
+        if f"SANDBOX EXCEPTION: {exc_type_name}" in output:
+            print("[CodeSuture Sandbox] Fix FAILED: original exception still occurs.")
+            return False
+        elif "SANDBOX EXCEPTION" in output:
+            print(f"[CodeSuture Sandbox] Fix FAILED: caused a new exception.\n{output}")
+            return False
+        elif result.returncode != 0:
+            print(f"[CodeSuture Sandbox] Fix FAILED: subprocess exited with error.\n{output}")
+            return False
+
+        print("[CodeSuture Sandbox] Fix PASSED!")
+        return True
+    except subprocess.TimeoutExpired:
+        print("[CodeSuture Sandbox] Fix FAILED: Timeout (possible infinite loop).")
+        return False
+    finally:
+        os.remove(source_path)
+        os.remove(runner_path)

codesuture/shadow.py

@@ -0,0 +1,20 @@
+SENTINEL_VALUES = {"", 0, 0.0, None, False, (), frozenset()}
+
+def is_sentinel(value) -> bool:
+    try:
+        if value in SENTINEL_VALUES:
+            return True
+        if value == [] or value == {}:
+            return True
+    except Exception:
+        pass
+    return False
+
+def shadow_check(func_name: str, return_value, guard_type: str):
+    if is_sentinel(return_value):
+        print(
+            f"[CodeSuture SHADOW] âš  {func_name}() returned sentinel "
+            f"value {return_value!r} after {guard_type} patch. "
+            f"Verify this default is safe for downstream consumers."
+        )
+