klongpy 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

klongpy/backends/base.py

@@ -5,6 +5,7 @@ All backends must implement the BackendProvider interface to ensure
 consistent behavior across numpy, torch, and any future backends.
 """
 from abc import ABC, abstractmethod
+import numpy as np
 
 
 def is_jagged_array(x):
@@ -142,14 +143,12 @@ class BackendProvider(ABC):
 
     def is_integer(self, x) -> bool:
         """Check if x is an integer type (scalar, numpy integer, or 0-dim integer tensor)."""
-        import numpy as np
         if issubclass(type(x), (int, np.integer)):
             return True
         return self.is_scalar_integer(x)
 
     def is_float(self, x) -> bool:
         """Check if x is a float type (scalar, numpy float, int, or 0-dim float tensor)."""
-        import numpy as np
         if issubclass(type(x), (float, np.floating, int)):
             return True
         return self.is_scalar_float(x) or self.is_scalar_integer(x)
@@ -180,7 +179,6 @@ class BackendProvider(ABC):
 
         Returns a truth value (0 or 1) suitable for Klong.
         """
-        import numpy as np
         return np.asarray(x, dtype=object) == np.asarray(y, dtype=object)
 
     def detach_if_needed(self, x):
@@ -195,16 +193,21 @@ class BackendProvider(ABC):
         """
         Convert array to integer type.
         """
-        import numpy as np
         return np.asarray(a, dtype=int) if self.is_array(a) else int(a)
 
+    def floor_to_int(self, a):
+        """
+        Floor a value and convert to integer.
+        """
+        result = np.floor(np.asarray(a, dtype=float))
+        return result.astype(int) if hasattr(result, 'astype') else int(result)
+
     def power(self, a, b):
         """
         Compute a^b, handling gradient tracking if applicable.
 
         Returns integer result if the result is a whole number.
         """
-        import numpy as np
         r = np.power(float(a) if isinstance(a, (int, np.integer)) else a, b)
         return r
 
@@ -216,6 +219,10 @@ class BackendProvider(ABC):
         """Whether this backend supports automatic differentiation."""
         return False
 
+    def array_equal(self, a, b) -> bool:
+        """Backend-native exact equality for arrays/tensors."""
+        return bool(np.array_equal(a, b))
+
     def create_grad_tensor(self, x):
         """Create a tensor that tracks gradients. Raises if not supported."""
         raise NotImplementedError("This backend does not support autograd")
@@ -315,6 +322,148 @@ class BackendProvider(ABC):
         )
 
 
+    def kg_equal(self, a, b):
+        """Compare two values or arrays for equality, handling nested arrays and tensors."""
+        if a is b:
+            return True
+
+        # Backend-native comparison for backend arrays
+        if self.is_backend_array(a) and self.is_backend_array(b):
+            return self.array_equal(a, b)
+
+        # Fast path for numpy arrays (non-object)
+        if isinstance(a, np.ndarray) and isinstance(b, np.ndarray):
+            if a.dtype != object and b.dtype != object:
+                return bool(np.array_equal(a, b))
+
+        # Convert backend arrays to numpy for mixed comparisons
+        if self.is_backend_array(a):
+            a = self.to_numpy(a)
+        if self.is_backend_array(b):
+            b = self.to_numpy(b)
+
+        # Fast path for numpy arrays (after any conversion)
+        if isinstance(a, np.ndarray) and isinstance(b, np.ndarray):
+            if a.dtype != object and b.dtype != object:
+                return bool(np.array_equal(a, b))
+
+        # Normalize 0-d numpy arrays to scalars for mixed comparisons
+        if isinstance(a, np.ndarray) and a.ndim == 0:
+            a = a.item()
+        if isinstance(b, np.ndarray) and b.ndim == 0:
+            b = b.item()
+
+        # List/sequence comparison
+        a_is_seq = isinstance(a, (list, tuple)) or (isinstance(a, np.ndarray) and a.ndim > 0)
+        b_is_seq = isinstance(b, (list, tuple)) or (isinstance(b, np.ndarray) and b.ndim > 0)
+        if a_is_seq or b_is_seq:
+            if not (a_is_seq and b_is_seq):
+                return False
+            if isinstance(a, (list, tuple)) and isinstance(b, (list, tuple)):
+                def _is_int_scalar(x):
+                    return isinstance(x, (int, bool, np.integer))
+                if len(a) == len(b) and len(a) >= 32 and all(_is_int_scalar(x) for x in a) and all(_is_int_scalar(y) for y in b):
+                    return a == b
+            # Fast path for object numpy arrays when possible
+            if isinstance(a, np.ndarray) and isinstance(b, np.ndarray) and a.dtype == object and b.dtype == object:
+                if a.size >= 128:
+                    try:
+                        return bool(np.array_equal(a, b))
+                    except Exception:
+                        pass
+            if len(a) != len(b):
+                return False
+            return all(self.kg_equal(x, y) for x, y in zip(a, b))
+
+        # Numeric scalars: tolerant comparison
+        if self.is_number(a) and self.is_number(b):
+            result = np.isclose(a, b)
+            if hasattr(result, 'item'):
+                return bool(result.item())
+            return bool(result)
+
+        # Fallback: direct equality
+        result = a == b
+        if hasattr(result, 'all'):
+            return bool(result.all())
+        if hasattr(result, 'item'):
+            return bool(result.item())
+        return bool(result)
+
+    def vec_fn(self, a, f):
+        """
+        Apply function f to array a, with support for nested object arrays.
+        """
+        if self.np.isarray(a) and a.dtype == 'O':
+            result = [self.vec_fn(x, f) if self._is_list(x) else f(x) for x in a]
+            return np.asarray(result, dtype=object)
+        return f(a)
+
+    def vec_fn2(self, a, b, f):
+        """
+        Apply function f to elements of a and b, handling nested structures.
+        """
+        if self.np.isarray(a):
+            if a.dtype == 'O':
+                if self.np.isarray(b):
+                    assert len(a) == len(b)
+                    return self.kg_asarray([self.vec_fn2(x, y, f) for x, y in zip(a, b)])
+                else:
+                    return self.kg_asarray([self.vec_fn2(x, b, f) for x in a])
+            elif self.np.isarray(b) and b.dtype == 'O':
+                assert len(a) == len(b)
+                return self.kg_asarray([self.vec_fn2(x, y, f) for x, y in zip(a, b)])
+        elif self.np.isarray(b) and b.dtype == 'O':
+            return self.kg_asarray([self.vec_fn2(a, x, f) for x in b])
+        return f(a, b)
+
+    def rec_fn(self, a, f):
+        """
+        Recursively apply function f to all elements of a nested structure.
+        """
+        return self.kg_asarray([self.rec_fn(x, f) for x in a]) if self._is_list(a) else f(a)
+
+    def _is_list(self, x):
+        """Check if x is a list-like structure (array or list, non-empty)."""
+        if isinstance(x, np.ndarray):
+            return x.size > 0
+        if isinstance(x, (list, tuple)):
+            return len(x) > 0
+        return False
+
+    @property
+    def device(self):
+        """Return the current device for this backend (e.g., 'cpu', 'cuda:0', 'mps')."""
+        return 'cpu'
+
+    def list_devices(self):
+        """
+        List available devices for this backend.
+
+        Returns:
+            list: List of available device names (e.g., ['cpu'], ['cpu', 'cuda:0', 'mps'])
+        """
+        return ['cpu']
+
+    def get_info(self):
+        """
+        Get comprehensive information about this backend.
+
+        Returns:
+            dict: Dictionary with backend name, current device, available devices,
+                  and feature support flags.
+        """
+        return {
+            'name': self.name,
+            'device': self.device,
+            'devices': self.list_devices(),
+            'supports_float64': self.supports_float64(),
+            'supports_strings': self.supports_strings(),
+            'supports_object_dtype': self.supports_object_dtype(),
+            'supports_autograd': self.supports_autograd(),
+        }
+
+
 class UnsupportedDtypeError(Exception):
     """Raised when an operation requires a dtype not supported by the backend."""
     pass

klongpy/backends/numpy_backend.py

@@ -22,7 +22,8 @@ class NumpyBackendProvider(BackendProvider):
     """NumPy-based backend provider."""
 
     def __init__(self, device=None):
-        # device parameter is ignored for numpy backend (accepted for API consistency)
+        if device is not None:
+            raise ValueError("Backend 'numpy' does not support device selection")
         self._np = np
         np.seterr(divide='ignore')
         warnings.filterwarnings("error", category=NumpyVisibleDeprecationWarning)

klongpy/backends/registry.py

@@ -0,0 +1,76 @@
+"""
+Backend registry for KlongPy.
+
+Owns backend registration, lookup, and lazy torch loading.
+"""
+import importlib
+import importlib.util
+
+from .base import BackendProvider
+from .numpy_backend import NumpyBackendProvider
+
+# Registry of available backends
+_BACKENDS = {}
+
+# Default backend name
+_DEFAULT_BACKEND = 'numpy'
+
+_TORCH_AVAILABLE = importlib.util.find_spec("torch") is not None
+_TORCH_BACKEND_LOADED = False
+TorchBackendProvider = None
+
+
+def register_backend(name: str, provider_class):
+    """Register a backend provider class."""
+    _BACKENDS[name] = provider_class
+
+
+def _load_torch_backend():
+    global _TORCH_BACKEND_LOADED, TorchBackendProvider
+    if _TORCH_BACKEND_LOADED or not _TORCH_AVAILABLE:
+        return
+    _torch_backend = importlib.import_module("klongpy.backends.torch_backend")
+    TorchBackendProvider = _torch_backend.TorchBackendProvider
+    register_backend('torch', TorchBackendProvider)
+    _TORCH_BACKEND_LOADED = True
+
+
+def get_backend(name: str = None, **kwargs) -> BackendProvider:
+    """
+    Get a backend provider instance.
+
+    Parameters
+    ----------
+    name : str, optional
+        Backend name ('numpy' or 'torch'). If None, uses default.
+    **kwargs
+        Additional arguments passed to the backend provider constructor.
+
+    Returns
+    -------
+    BackendProvider
+        The backend provider instance.
+    """
+    if name is None:
+        name = _DEFAULT_BACKEND
+
+    if name == 'torch':
+        _load_torch_backend()
+
+    if name not in _BACKENDS:
+        available = ', '.join(_BACKENDS.keys())
+        raise ValueError(f"Unknown backend: '{name}'. Available: {available}")
+
+    return _BACKENDS[name](**kwargs)
+
+
+def list_backends():
+    """Return list of available backend names."""
+    backends = list(_BACKENDS.keys())
+    if _TORCH_AVAILABLE and 'torch' not in backends:
+        backends.append('torch')
+    return backends
+
+
+# Register built-in backends
+register_backend('numpy', NumpyBackendProvider)

klongpy/backends/torch_backend.py

@@ -7,8 +7,10 @@ It does not support object dtype or string operations.
 import math
 import numpy
 import torch
+import torch.autograd.functional as torch_autograd_functional
 
 from .base import BackendProvider, UnsupportedDtypeError, is_jagged_array
+from ..autograd import AutogradChainBrokenError, NonScalarLossError, _invoke_fn
 
 # numpy 2.x moved VisibleDeprecationWarning to numpy.exceptions
 from numpy.exceptions import VisibleDeprecationWarning as NumpyVisibleDeprecationWarning
@@ -208,26 +210,26 @@ class TorchBackend:
             return torch.from_numpy(a).to(self.device)
         # Check if input is a list/tuple of tensors - use stack to preserve gradients
         if isinstance(a, (list, tuple)) and len(a) > 0 and all(isinstance(x, torch.Tensor) for x in a):
-            # torch.stack preserves requires_grad, torch.tensor does not
             result = torch.stack(a)
             if result.device != self.device:
                 result = result.to(self.device)
-            # Handle float64 on MPS
             if result.dtype == torch.float64 and self.device.type == 'mps':
                 result = result.to(torch.float32)
             return result
-        # Check if input contains any arrays/tensors mixed with non-arrays - these need object dtype
-        if isinstance(a, (list, tuple)) and len(a) > 0:
-            has_array = any(isinstance(x, (torch.Tensor, numpy.ndarray, list)) for x in a)
-            has_scalar = any(isinstance(x, (int, float)) and not isinstance(x, bool) for x in a)
-            if has_array and has_scalar:
-                # Mixed array/scalar list - can't represent in torch without losing structure
+        # For all other lists/tuples, convert via numpy (faster than torch.tensor for nested/mixed data)
+        if isinstance(a, (list, tuple)):
+            arr = numpy.asarray(a)
+            if arr.dtype == object:
                 raise TorchUnsupportedDtypeError(
-                    "PyTorch backend cannot convert mixed array/scalar lists without losing structure."
+                    "PyTorch backend does not support object dtype arrays."
                 )
+            # Convert float64 to float32 to match torch.tensor's default behavior
+            if arr.dtype == numpy.float64:
+                arr = arr.astype(numpy.float32)
+            return torch.from_numpy(arr).to(self.device)
+        # Scalar or other type
         try:
             t = torch.tensor(a, device=self.device)
-            # Handle float64 on MPS
             if t.dtype == torch.float64 and self.device.type == 'mps':
                 t = t.to(torch.float32)
             return t
@@ -509,6 +511,21 @@ class TorchBackendProvider(BackendProvider):
     """PyTorch-based backend provider."""
 
     def __init__(self, device=None):
+        if device is not None:
+            try:
+                torch_device = torch.device(device)
+            except Exception as exc:
+                raise ValueError(f"Invalid torch device '{device}': {exc}")
+            if torch_device.type == 'cuda':
+                if not torch.cuda.is_available():
+                    raise ValueError(f"Torch device '{device}' is not available (cuda not available)")
+                if torch_device.index is not None and torch_device.index >= torch.cuda.device_count():
+                    raise ValueError(f"Torch device '{device}' is not available (device index out of range)")
+            if torch_device.type == 'mps':
+                if not (hasattr(torch.backends, 'mps') and torch.backends.mps.is_available()):
+                    raise ValueError(f"Torch device '{device}' is not available (mps not available)")
+            if torch_device.type not in {'cpu', 'cuda', 'mps'}:
+                raise ValueError(f"Torch device type '{torch_device.type}' is not supported")
         self._torch_backend = TorchBackend(device)
         self._device = device
 
@@ -524,6 +541,17 @@ class TorchBackendProvider(BackendProvider):
     def device(self):
         return self._torch_backend.device
 
+    def list_devices(self):
+        """List available torch devices (cpu, cuda, mps)."""
+        devices = ['cpu']
+        if torch.cuda.is_available():
+            devices.append('cuda')
+            for i in range(torch.cuda.device_count()):
+                devices.append(f'cuda:{i}')
+        if hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
+            devices.append('mps')
+        return devices
+
     def supports_object_dtype(self) -> bool:
         return False
 
@@ -608,6 +636,16 @@ class TorchBackendProvider(BackendProvider):
         # Default numpy comparison
         return numpy.asarray(x, dtype=object) == numpy.asarray(y, dtype=object)
 
+    def array_equal(self, a, b) -> bool:
+        """Backend-native exact equality for torch tensors."""
+        if not isinstance(a, torch.Tensor) or not isinstance(b, torch.Tensor):
+            return False
+        try:
+            return bool(torch.equal(a, b))
+        except RuntimeError:
+            # Fall back to CPU comparison if devices mismatch
+            return bool(torch.equal(a.cpu(), b.cpu()))
+
     def detach_if_needed(self, x):
         """Detach tensor if it requires grad, to allow type conversions."""
         if isinstance(x, torch.Tensor) and x.requires_grad:
@@ -620,14 +658,28 @@ class TorchBackendProvider(BackendProvider):
             return a.to(int)
         return numpy.asarray(a, dtype=int) if isinstance(a, numpy.ndarray) else int(a)
 
+    def floor_to_int(self, a):
+        """Floor a value and convert to integer."""
+        if not isinstance(a, torch.Tensor):
+            a = self.kg_asarray(a)
+        return torch.floor(a.float()).to(int)
+
     def power(self, a, b):
         """Compute a^b, handling gradient tracking for torch tensors."""
-        # Use torch.pow for tensors to maintain gradients when possible
         if isinstance(a, torch.Tensor):
+            # Handle negative exponents - torch doesn't support int^negative
+            if isinstance(b, torch.Tensor) and b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64) and (b < 0).any():
+                base = a.float() if a.dtype in (torch.int8, torch.int16, torch.int32, torch.int64) else a
+                result = base.pow(b.abs()).float()
+                return torch.where(b < 0, 1.0 / result, result)
+            b_val = b.item() if isinstance(b, torch.Tensor) and b.ndim == 0 else b
+            if isinstance(b_val, (int, numpy.integer)) and b_val < 0:
+                a = a.float()
             return a.pow(b)
         # For numpy arrays or scalars
         a_val = float(a) if isinstance(a, (int, numpy.integer)) else a
-        return numpy.power(a_val, b)
+        b_val = b.item() if isinstance(b, torch.Tensor) and b.ndim == 0 else (b.cpu().numpy() if isinstance(b, torch.Tensor) else b)
+        return numpy.power(a_val, b_val)
 
     def has_gradient(self, x) -> bool:
         """Check if x is tracking gradients."""
@@ -648,8 +700,6 @@ class TorchBackendProvider(BackendProvider):
 
     def compute_autograd(self, func, x):
         """Compute gradient using PyTorch automatic differentiation."""
-        from ..autograd import AutogradChainBrokenError, NonScalarLossError
-
         x_tensor = self.create_grad_tensor(x)
 
         # Compute the function value
@@ -700,8 +750,6 @@ class TorchBackendProvider(BackendProvider):
         Returns:
             List of gradients, one per parameter
         """
-        from ..autograd import AutogradChainBrokenError, NonScalarLossError
-
         # Create grad tensors for all parameters
         grad_tensors = [self.create_grad_tensor(p) for p in params]
 
@@ -744,12 +792,10 @@ class TorchBackendProvider(BackendProvider):
         Returns:
             Jacobian matrix J where J[i,j] = df_i/dx_j
         """
-        import torch.autograd.functional as F
-
         x_tensor = self.create_grad_tensor(x)
 
         # torch.autograd.functional.jacobian expects func(inputs) -> outputs
-        jacobian = F.jacobian(func, x_tensor)
+        jacobian = torch_autograd_functional.jacobian(func, x_tensor)
 
         return jacobian
 
@@ -812,7 +858,14 @@ class TorchBackendProvider(BackendProvider):
         _ = compiled_fn(example_input)
 
         if output_path is None:
-            return compiled_fn
+            # Wrap with Klong-convention parameter name (x) so that
+            # KGLambda introspection binds the argument correctly when
+            # the compiled function is stored via ::
+            def klong_compiled(x):
+                if not isinstance(x, torch.Tensor):
+                    x = self.create_grad_tensor(x)
+                return compiled_fn(x)
+            return klong_compiled
 
         # Export the function graph for inspection
         try:
@@ -920,11 +973,14 @@ class TorchBackendProvider(BackendProvider):
         Returns:
             1 if gradients are correct, raises error otherwise
         """
-        from ..autograd import _invoke_fn
+        # Gradcheck requires float64 which is only supported on CPU
+        if self.device.type != 'cpu':
+            raise RuntimeError(
+                f".gradcheck() requires CPU device, got '{self.device.type}'. "
+                "Run with: kgpy --backend torch --device cpu"
+            )
 
-        # Determine dtype based on device support
-        use_float32 = self.device.type == 'mps'  # MPS doesn't support float64
-        dtype = torch.float32 if use_float32 else torch.float64
+        dtype = torch.float64
 
         # Wrap the Klong function
         def wrapped_fn(v):
@@ -934,19 +990,15 @@ class TorchBackendProvider(BackendProvider):
                 result = result.sum()
             return result
 
-        # Convert inputs to tensor on CPU for gradcheck (avoids MPS float64 issues)
+        # Convert inputs to tensor on CPU for gradcheck
         if isinstance(inputs, (list, tuple)) and not isinstance(inputs[0], torch.Tensor):
             tensor_inputs = torch.tensor(inputs, dtype=dtype, device='cpu', requires_grad=True)
         elif not isinstance(inputs, torch.Tensor):
             tensor_inputs = torch.tensor([inputs], dtype=dtype, device='cpu', requires_grad=True)
         else:
-            tensor_inputs = inputs.to(dtype=dtype, device='cpu').requires_grad_(True)
+            tensor_inputs = inputs.detach().cpu().to(dtype=dtype).requires_grad_(True)
 
-        # Run gradcheck with adjusted tolerances for float32
-        if use_float32:
-            result = self.gradcheck(wrapped_fn, (tensor_inputs,), eps=1e-4, atol=1e-3, rtol=1e-2)
-        else:
-            result = self.gradcheck(wrapped_fn, (tensor_inputs,))
+        result = self.gradcheck(wrapped_fn, (tensor_inputs,))
 
         return 1 if result else 0
 

klongpy/cli.py

@@ -7,6 +7,8 @@ See https://t3x.org/klong/klong-ref.txt.html for additional details.
 
 import argparse
 import asyncio
+import importlib
+import importlib.util
 import importlib.metadata
 import os
 import sys
@@ -15,10 +17,13 @@ import timeit
 
 import colorama
 
-from klongpy import KlongInterpreter
+from klongpy import KlongInterpreter, list_backends
 from klongpy.core import kg_write
 from klongpy.repl import cleanup_repl, create_repl
 
+_READLINE_SPEC = importlib.util.find_spec("readline")
+readline = importlib.import_module("readline") if _READLINE_SPEC else None
+
 
 def sys_cmd_shell(klong, cmd):
     """
@@ -191,11 +196,13 @@ async def repl_eval(klong, p, verbose=True):
     return r
 
 
-def show_repl_header(ipc_addr=None):
+def show_repl_header(backend_name, device_name=None, ipc_addr=None):
     print()
     print(f"{colorama.Fore.GREEN}Welcome to KlongPy REPL v{importlib.metadata.distribution('klongpy').version}")
     print(f"{colorama.Fore.GREEN}Author: Brian Guarraci")
     print(f"{colorama.Fore.GREEN}Web: http://klongpy.org")
+    device_str = f" ({device_name})" if device_name else ""
+    print(f"{colorama.Fore.CYAN}Backend: {backend_name}{device_str}")
     print(f"{colorama.Fore.YELLOW}]h for help; Ctrl-D or ]q to quit")
     print()
     if ipc_addr:
@@ -239,7 +246,19 @@ class ConsoleInputHandler:
                     print("\rbye!")
                     break
                 except KeyboardInterrupt:
-                    print(failure("\nkg: error: interrupted"))
+                    buf = ""
+                    if readline is not None:
+                        try:
+                            buf = readline.get_line_buffer()
+                        except Exception:
+                            buf = ""
+                    if buf:
+                        print()
+                        continue
+                    print("\rbye!")
+                    if exit_state is not None:
+                        exit_state["code"] = 130
+                    break
                 except Exception as e:
                     print(failure(f"Error: {e.args}"))
                     import traceback
@@ -256,6 +275,10 @@ async def run_in_klong(klong, s):
 
 
 def run_file(klong_loop, klong, fname, verbose=False):
+    # Add script directory to sys.path so .py/.pyf imports resolve sibling modules
+    script_dir = os.path.dirname(os.path.abspath(fname))
+    if script_dir not in sys.path:
+        sys.path.insert(0, script_dir)
     with open(fname, "r") as f:
         content = f.read()
     return run_in_loop(klong_loop, run_in_klong(klong, content))
@@ -281,21 +304,35 @@ def main():
     parser.add_argument('-t', '--test', help='test program from file')
     parser.add_argument('-v', '--verbose', help='enable verbose output', action="store_true")
     parser.add_argument('-d', '--debug', help='enable debug mode', action="store_true")
+    parser.add_argument('--backend', help='set array backend', type=str.lower, choices=list_backends())
+    parser.add_argument('--device', help='set backend device (torch only)', type=str)
     parser.add_argument('filename', nargs='?', help='filename to be run if no flags are specified')
 
     args = parser.parse_args(main_args[1:])
 
+    # Default to torch backend if available and not explicitly set
+    if args.backend is None:
+        available_backends = list_backends()
+        if 'torch' in available_backends:
+            args.backend = 'torch'
+
     if args.debug:
         print("args: ", args)
 
     if args.expr:
-        klong = KlongInterpreter()
+        try:
+            klong = KlongInterpreter(backend=args.backend, device=args.device)
+        except ValueError as exc:
+            parser.error(str(exc))
         result = klong(args.expr)
         if result is not None:
             print(kg_write(result, klong._backend, display=False))
         return
 
-    klong, loops = create_repl(debug=args.debug)
+    try:
+        klong, loops = create_repl(debug=args.debug, backend=args.backend, device=args.device)
+    except ValueError as exc:
+        parser.error(str(exc))
     io_loop, _, _, klong_loop, _, _ = loops
     shutdown_event = klong['.system']['closeEvent']
 
@@ -361,9 +398,15 @@ def main():
         if run_repl:
             exit_state = {"code": None}
             colorama.init(autoreset=True)
-            show_repl_header(args.server)
+            backend_name = klong._backend.name
+            device_name = str(klong._backend.device) if hasattr(klong._backend, 'device') else None
+            show_repl_header(backend_name, device_name, args.server)
             console_loop.create_task(ConsoleInputHandler.input_producer(console_loop, klong_loop, klong, args.verbose, exit_state))
-            console_loop.run_forever()
+            try:
+                console_loop.run_forever()
+            except KeyboardInterrupt:
+                exit_state["code"] = 130
+                console_loop.stop()
             console_loop.close()
             if exit_state["code"] is not None:
                 exit_code = exit_state["code"]