perf: reuse kernel WebSocket connection for multi-cell execution

Previously each cell created a new KernelClient (connect/disconnect
cycle). Now _exec_file uses a single kernel_connection context manager
for all cells. Also passes timeout to kernel.execute() which was
previously ignored (defaulting to 10s).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: TTTPOB

j_cli/commands/exec_cmd.py

@@ -26,7 +26,6 @@ def exec_cmd(ctx: Context, session_id: str, code: str | None, file_path: str | N
 
     try:
         from j_cli.server import get_kernel_id_for_session
-        from j_cli.kernel import execute_code
 
         kernel_id = get_kernel_id_for_session(ctx.server_url, session_id, ctx.token)
     except Exception as e:
@@ -66,7 +65,7 @@ def _exec_file(ctx: Context, kernel_id: str, file_path: str, cell_spec: str | No
     """Execute cells from a file."""
     try:
         from j_cli.parser import parse_file, parse_cell_spec
-        from j_cli.kernel import execute_code
+        from j_cli.kernel import kernel_connection
 
         parsed = parse_file(file_path)
 
@@ -84,24 +83,25 @@ def _exec_file(ctx: Context, kernel_id: str, file_path: str, cell_spec: str | No
         cell_results = []
         all_outputs_human = []
 
-        for cell in selected:
-            result = execute_code(ctx.server_url, ctx.token, kernel_id, cell.source, timeout)
-            raw_outputs = result.get("outputs", [])
-            outputs = process_outputs(raw_outputs)
-
-            cell_results.append({
-                "cell_index": cell.index,
-                "source_preview": cell.source[:80].replace("\n", " "),
-                "outputs": outputs,
-                "raw_outputs": raw_outputs,
-                "execution_count": result.get("execution_count"),
-            })
-
-            if not ctx.use_json:
-                all_outputs_human.append(f"--- cell {cell.index} ---")
-                text = format_outputs_human(outputs)
-                if text:
-                    all_outputs_human.append(text)
+        with kernel_connection(ctx.server_url, ctx.token, kernel_id) as kernel:
+            for cell in selected:
+                result = kernel.execute(cell.source, timeout=timeout)
+                raw_outputs = result.get("outputs", [])
+                outputs = process_outputs(raw_outputs)
+
+                cell_results.append({
+                    "cell_index": cell.index,
+                    "source_preview": cell.source[:80].replace("\n", " "),
+                    "outputs": outputs,
+                    "raw_outputs": raw_outputs,
+                    "execution_count": result.get("execution_count"),
+                })
+
+                if not ctx.use_json:
+                    all_outputs_human.append(f"--- cell {cell.index} ---")
+                    text = format_outputs_human(outputs)
+                    if text:
+                        all_outputs_human.append(text)
 
         # Write back to notebook
         notebook_updated = None

j_cli/kernel.py

@@ -1,8 +1,25 @@
 """Kernel execution via jupyter-kernel-client (WebSocket)."""
 
+from contextlib import contextmanager
+
 from jupyter_kernel_client import KernelClient
 
 
+@contextmanager
+def kernel_connection(server_url: str, token: str | None, kernel_id: str):
+    """Context manager that yields a started KernelClient."""
+    kernel = KernelClient(
+        server_url=server_url,
+        token=token,
+        kernel_id=kernel_id,
+    )
+    kernel.start()
+    try:
+        yield kernel
+    finally:
+        kernel.stop()
+
+
 def execute_code(
     server_url: str,
     token: str | None,
@@ -15,14 +32,5 @@ def execute_code(
     Returns dict with 'outputs' key containing list of output dicts,
     and 'execution_count'.
     """
-    kernel = KernelClient(
-        server_url=server_url,
-        token=token,
-        kernel_id=kernel_id,
-    )
-    kernel.start()
-    try:
-        result = kernel.execute(code)
-        return result
-    finally:
-        kernel.stop()
+    with kernel_connection(server_url, token, kernel_id) as kernel:
+        return kernel.execute(code, timeout=timeout)