kapsel-cli 0.6.3__tar.gz → 0.7.2__tar.gz

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapsel-cli
-Version: 0.6.3
+Version: 0.7.2
 Summary: Next-generation cross-platform terminal capsule & ergonomic shell multiplexer with context-aware command translation and 1,000+ CLI completions.
 Author-email: MrEiu <k648888@vip.qq.com>
 License: MIT

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/__init__.py

@@ -3,4 +3,4 @@ Kapsel: Cross-platform adaptive smart terminal capsule.
 Wrap complexity, expose simplicity.
 """
 
-__version__ = "0.6.3"
+__version__ = "0.7.2"

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/cli.py

@@ -102,17 +102,18 @@ def main(args: Optional[List[str]] = None) -> int:
         if not stripped:
             continue
 
-        normalized = " ".join(stripped.lower().split())
-        if normalized in ("exit", "quit", "bye"):
-            engine.history_mgr.record_command(command=user_input, mode="builtin")
-            os.environ.pop("KAPSEL_ACTIVE", None)
-            console.print("[dim]Exited Kapsel.[/]")
-            break
-
-        if normalized in ("restart", "kapsel restart", "reload"):
-            engine.history_mgr.record_command(command=user_input, mode="builtin")
-            from kapsel.completion.kps.builtins.restart import handle_restart
-            return handle_restart(console=console)
+        if "\n" not in stripped:
+            normalized = " ".join(stripped.lower().split())
+            if normalized in ("exit", "quit", "bye"):
+                engine.history_mgr.record_command(command=user_input, mode="builtin")
+                os.environ.pop("KAPSEL_ACTIVE", None)
+                console.print("[dim]Exited Kapsel.[/]")
+                break
+
+            if normalized in ("restart", "kapsel restart", "reload"):
+                engine.history_mgr.record_command(command=user_input, mode="builtin")
+                from kapsel.completion.kps.builtins.restart import handle_restart
+                return handle_restart(console=console)
 
         try:
             result = engine.dispatch(user_input)

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/completion/carapace_installer.py

@@ -192,9 +192,10 @@ def install_carapace(
 
 def ensure_carapace_installed(console: Optional[Console] = None) -> bool:
     """
-    Auto-bootstraps Carapace completion engine on first launch if not already available.
-    Zero-overhead (0ms) on subsequent launches when already installed.
-    Gracefully falls back to basic completion if offline, preventing any startup crash.
+    Checks if Carapace completion engine is available.
+    If not installed, prints a lightweight non-blocking notice and enters immediately.
+    Never blocks terminal startup with network downloads.
+    Users can install it anytime on demand using 'kapsel setup-completion'.
     """
     from kapsel.completion.carapace_engine import get_carapace_engine
 
@@ -203,16 +204,9 @@ def ensure_carapace_installed(console: Optional[Console] = None) -> bool:
         return True
 
     con = console or Console(legacy_windows=False)
-    con.print("[bold #00f0ff]🎯 First Launch: Auto-initializing Carapace completion engine (1,000+ tools)...[/]")
-
-    try:
-        success = install_carapace(console=con, force=False)
-        return success
-    except Exception as e:
-        logger.warning(f"Failed to auto-bootstrap Carapace: {e}")
-        con.print(
-            f"[yellow]Notice: Could not automatically setup Carapace ({e}). "
-            f"Continuing in basic autocompletion mode.[/]\n"
-        )
-        return False
+    con.print(
+        "[dim]ℹ Notice: Carapace completion engine not detected. Running in standard autocompletion mode.[/]\n"
+        "[dim]  (Optional: run '[bold cyan]kapsel setup-completion[/]' to enable 1,000+ tool completions)[/]\n"
+    )
+    return False
 

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/completion/kps/builtins/add.py

@@ -60,6 +60,26 @@ def _check_plugin_already_installed(
     return False, None, None
 
 
+def _get_installed_plugin_names(is_dev: bool = False) -> Set[str]:
+    """Returns set of all installed and enabled plugin names."""
+    installed = set()
+    global_plugins_dir = get_kapsel_dir() / "plugins"
+    if global_plugins_dir.is_dir():
+        for p in global_plugins_dir.iterdir():
+            if p.is_dir() and ((p / "__init__.py").exists() or (p / "plugin.py").exists()):
+                installed.add(p.name.lower())
+    if is_dev:
+        dev_dir = Path.cwd() / "plugins"
+        if dev_dir.is_dir():
+            for p in dev_dir.iterdir():
+                if p.is_dir() and ((p / "__init__.py").exists() or (p / "plugin.py").exists()):
+                    installed.add(p.name.lower())
+    cfg = load_config()
+    for ep in (cfg.enabled_plugins or []):
+        installed.add(ep.lower())
+    return installed
+
+
 def _install_single_plugin(
     target_raw: str,
     con: Console,
@@ -212,14 +232,14 @@ def _handle_add_batch_concurrent(
     already_enabled = set(p.lower() for p in (cfg.enabled_plugins or []))
 
     # Partition targets into uninstalled vs already-installed
+    installed_names = _get_installed_plugin_names()
     uninstalled: List[str] = []
     already_done: List[str] = []
     for t in targets:
         t_clean = t.strip()
         if not t_clean:
             continue
-        is_inst, _, _ = _check_plugin_already_installed(t_clean, is_dev=is_dev)
-        if is_inst or t_clean.lower() in already_enabled:
+        if t_clean.lower() in installed_names:
             already_done.append(t_clean)
         else:
             uninstalled.append(t_clean)
@@ -372,12 +392,11 @@ def _handle_add_all(con: Console, is_dev: bool = False, max_workers: int = 4) ->
     cfg = load_config()
     already_enabled = set(p.lower() for p in (cfg.enabled_plugins or []))
 
-    # Check both config.enabled_plugins and actual on-disk installation status with version
+    installed_names = _get_installed_plugin_names(is_dev=is_dev)
     uninstalled: List[str] = []
     already_installed: List[str] = []
     for p in ordered_plugins:
-        is_inst, _, _ = _check_plugin_already_installed(p, is_dev=is_dev)
-        if is_inst or p.lower() in already_enabled:
+        if p.lower() in installed_names:
             already_installed.append(p)
         else:
             uninstalled.append(p)

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/completion/kps/builtins/upgrade.py

@@ -394,17 +394,38 @@ def handle_upgrade(args: List[str], console: Optional[Console] = None) -> int:
                 con.print(f"[dim]{_('Cancelled.')}[/]\n")
                 return 0
 
-        # Perform plugin update download
+        # Perform plugin update download (Stage 1: Plugin package itself)
         dest_dir = info["dir"] or (get_kapsel_dir() / "plugins" / target_plugin)
         con.print(f"[dim]{_('Downloading and updating plugin package...')}[/]")
         if fetch_plugin_from_remote(target_plugin, dest_dir, con):
-            install_plugin_dependencies(dest_dir, con)
+            con.print(f"[bold #10b981]✔ {_('Plugin')} '[bold #00f0ff]{target_plugin}[/]' {_('successfully updated to')} v{info['latest']}![/]\n")
+
+            # Stage 2: Prompt for optional dependency installation
+            has_deps = (dest_dir / "tools.yaml").is_file() or (dest_dir / "install.py").is_file()
+            if has_deps:
+                should_install_deps = auto_yes
+                if not auto_yes:
+                    ans = prompt_user_choice(
+                        f"Install external dependencies for '{target_plugin}'? (External tool installation may fail) ([Enter] Yes / [s] Skip): ",
+                        default="y",
+                    )
+                    should_install_deps = ans in ("y", "yes")
+
+                if should_install_deps:
+                    con.print(f"[dim]Installing tool dependencies for '[bold #00f0ff]{target_plugin}[/]'...[/]")
+                    ok = install_plugin_dependencies(dest_dir, con)
+                    if ok:
+                        con.print(f"[bold #10b981]✔ Dependencies for '{target_plugin}' installed successfully.[/]\n")
+                    else:
+                        con.print(f"[yellow]⚠ Warning: Tool dependency installation encountered errors. You can run 'kps install {target_plugin}' or 'kps mend' to check and repair.[/]\n")
+                else:
+                    con.print(f"[dim]Skipped dependency installation. You can run 'kps install {target_plugin}' or 'kps mend' anytime.[/]\n")
+
             try:
                 from kapsel.completion.spec_manager import CarapaceSpecManager
                 CarapaceSpecManager().sync_specs()
             except Exception:
                 pass
-            con.print(f"[bold #10b981]✔ {_('Plugin')} '[bold #00f0ff]{target_plugin}[/]' {_('successfully updated to')} v{info['latest']}![/]\n")
             return 0
         else:
             con.print(f"[bold #f43f5e]✘ {_('Failed to download update for')} '{target_plugin}'.[/]\n")
@@ -542,7 +563,6 @@ def handle_upgrade(args: List[str], console: Optional[Console] = None) -> int:
 
         try:
             if fetch_plugin_from_remote(name, dest_dir, con):
-                install_plugin_dependencies(dest_dir, con)
                 with _CONSOLE_LOCK:
                     con.print(f"  [bold #10b981]✔ {_('Updated')} {name} {_('to')} v{latest_ver}[/]")
                 return True, name, f"v{latest_ver}"
@@ -572,6 +592,41 @@ def handle_upgrade(args: List[str], console: Optional[Console] = None) -> int:
                     else:
                         failed_plugins.append((name, detail))
 
+    # Stage 2: Prompt to install dependencies for updated plugins
+    plugins_with_deps: List[Tuple[str, Path]] = []
+    for name in succeeded_plugins:
+        p_dir = None
+        for p in upgradable_plugins:
+            if p["name"] == name:
+                p_dir = p.get("dir") or (get_kapsel_dir() / "plugins" / name)
+                break
+        if p_dir and ((p_dir / "tools.yaml").is_file() or (p_dir / "install.py").is_file()):
+            plugins_with_deps.append((name, p_dir))
+
+    if plugins_with_deps:
+        con.print(f"\n[bold #00f0ff]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/]")
+        con.print(f"[bold #00f0ff]📦 Plugin Dependencies Setup[/]")
+        con.print(f"[dim]{len(plugins_with_deps)} updated plugin(s) contain external tool dependencies.[/]")
+
+        should_install_all_deps = auto_yes
+        if not auto_yes:
+            dep_ans = prompt_user_choice(
+                f"Install external dependencies for {len(plugins_with_deps)} plugin(s)? (External tool installation may fail) ([Enter] Yes / [s] Skip): ",
+                default="y",
+            )
+            should_install_all_deps = dep_ans in ("y", "yes")
+
+        if should_install_all_deps:
+            for p_name, p_dir in plugins_with_deps:
+                con.print(f"\n[dim]Installing tool dependencies for '[bold #00f0ff]{p_name}[/]'...[/]")
+                ok = install_plugin_dependencies(p_dir, con)
+                if ok:
+                    con.print(f"  [bold #10b981]✔ Dependencies for '{p_name}' installed successfully.[/]")
+                else:
+                    con.print(f"  [yellow]⚠ Warning: Dependency installation for '{p_name}' encountered errors. Run 'kps install {p_name}' or 'kps mend' to check and repair.[/]")
+        else:
+            con.print("[dim]Skipped dependency installation. You can run 'kps install <plugin>' or 'kps mend' anytime.[/]")
+
     # Re-sync completion specifications
     try:
         from kapsel.completion.spec_manager import CarapaceSpecManager

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/completion/kps/dispatcher.py

@@ -133,6 +133,7 @@ def _handle_kp_command(
         con.print("[dim]Executes multiple commands or pasted blocks asynchronously in the background.[/]\n")
         con.print("[bold white]Usage:[/]")
         con.print("  [bold #a855f7]kp <commands...>[/]             Execute commands sequentially in background (atomic, non-blocking)")
+        con.print("  [bold #a855f7]kp -s <commands...>[/]          Execute commands sequentially in background (explicit sequential)")
         con.print("  [bold #a855f7]kp -c <commands...>[/]          Execute commands concurrently in background parallel tracks")
         con.print("  [bold #a855f7]kp attach [id][/]                Attach to running block as interactive sub-terminal (二级终端)")
         con.print("  [bold #a855f7]kp status[/]                    List session blocks, running status, PID, and exit codes")
@@ -140,6 +141,7 @@ def _handle_kp_command(
         con.print("  [bold #a855f7]kp stop <id>[/]                 Terminate a running background block\n")
         con.print("[bold white]Examples:[/]")
         con.print("  kp npm run dev               (Runs dev server in background, prompt stays clean)")
+        con.print("  kp -s git pull\\npnpm build    (Runs tasks sequentially in background)")
         con.print("  kp -c pnpm build:app\\npnpm build:docs         (Runs build tasks concurrently in parallel)\n")
         return 0
 
@@ -262,6 +264,15 @@ def _handle_kp_command(
     elif sub.startswith("-c\n") or sub.startswith("--concurrent\n"):
         is_concurrent = True
         body = sub.split("\n", 1)[1]
+    elif sub.startswith("-s ") or sub.startswith("--sequential "):
+        is_concurrent = False
+        body = sub.split(" ", 1)[1]
+    elif sub == "-s" or sub == "--sequential":
+        con.print("[bold #f43f5e]Error:[/] Please provide commands to execute with 'kp -s'.\n")
+        return 1
+    elif sub.startswith("-s\n") or sub.startswith("--sequential\n"):
+        is_concurrent = False
+        body = sub.split("\n", 1)[1]
 
     commands = split_commands(body)
     if not commands:

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/core/block/runner.py

@@ -20,19 +20,114 @@ from kapsel.core.block.model import BlockStatus, CommandBlock
 from kapsel.core.block.registry import get_block_registry
 
 
+def _normalize_continuation_spaces(text: str) -> str:
+    """Replaces unquoted newlines (from continuation lines) with spaces and collapses indentation."""
+    if "\n" not in text:
+        return text
+
+    result = []
+    in_single = False
+    in_double = False
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        if (ch == "\\" or ch == "`") and not in_single and i + 1 < len(text):
+            result.append(ch)
+            result.append(text[i + 1])
+            i += 2
+            continue
+        if ch == "'" and not in_double:
+            in_single = not in_single
+            result.append(ch)
+        elif ch == '"' and not in_single:
+            in_double = not in_double
+            result.append(ch)
+        elif ch == "\n" and not in_single and not in_double:
+            if result and result[-1] != " ":
+                result.append(" ")
+            while i + 1 < len(text) and text[i + 1] in (" ", "\t"):
+                i += 1
+        else:
+            result.append(ch)
+        i += 1
+
+    return "".join(result).strip()
+
+
 def split_commands(raw_text: str) -> List[str]:
     """
-    Parses multi-line or delimited text into individual commands,
-    ignoring empty lines and pure comments.
+    Parses multi-line or delimited text into individual executable commands.
+    - Preserves newlines within unclosed quotes ('', "").
+    - Handles line continuation characters ('\\' in POSIX/Bash, '`' in PowerShell)
+      by joining them into a single command with continuation characters stripped.
+    - Handles trailing pipeline ('|') and logical ('&&', '||') continuations.
+    - Ignores empty whitespace lines.
+    - Does NOT filter '#' lines (leaves comments/commands intact for the shell).
     """
-    lines = raw_text.strip().splitlines()
-    result: List[str] = []
+    if not raw_text or not raw_text.strip():
+        return []
+
+    lines = raw_text.splitlines()
+    commands: List[str] = []
+    current_parts: List[str] = []
+    in_single_quote = False
+    in_double_quote = False
+
     for line in lines:
-        cleaned = line.strip()
-        if not cleaned or cleaned.startswith("#"):
+        stripped = line.strip()
+        if not stripped and not current_parts and not in_single_quote and not in_double_quote:
+            continue
+
+        # Count quotes in this line, ignoring escaped quotes
+        i = 0
+        while i < len(line):
+            ch = line[i]
+            if (ch == "\\" or ch == "`") and not in_single_quote and i + 1 < len(line):
+                i += 2
+                continue
+            if ch == "'" and not in_double_quote:
+                in_single_quote = not in_single_quote
+            elif ch == '"' and not in_single_quote:
+                in_double_quote = not in_double_quote
+            i += 1
+
+        # If currently inside an open quote, line continues unconditionally
+        if in_single_quote or in_double_quote:
+            current_parts.append(line)
             continue
-        result.append(cleaned)
-    return result
+
+        # Outside quotes: check if line ends with a continuation token
+        r_stripped = line.rstrip()
+        is_continuation = False
+        continuation_clean = line
+
+        if r_stripped.endswith("\\"):
+            is_continuation = True
+            continuation_clean = r_stripped[:-1].rstrip()
+        elif r_stripped.endswith("`"):
+            is_continuation = True
+            continuation_clean = r_stripped[:-1].rstrip()
+        elif r_stripped.endswith("|") or r_stripped.endswith("&&") or r_stripped.endswith("||"):
+            is_continuation = True
+            continuation_clean = r_stripped
+
+        if is_continuation:
+            current_parts.append(continuation_clean)
+        else:
+            current_parts.append(line)
+            full_cmd = "\n".join(current_parts).strip()
+            full_cmd = _normalize_continuation_spaces(full_cmd)
+            if full_cmd:
+                commands.append(full_cmd)
+            current_parts = []
+
+    if current_parts:
+        leftover = "\n".join(current_parts).strip()
+        leftover = _normalize_continuation_spaces(leftover)
+        if leftover:
+            commands.append(leftover)
+
+    return commands
 
 
 def _run_single_command_process(cmd: str, cwd: str) -> Tuple[int, str, int]:

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/core/executor.py

@@ -81,6 +81,11 @@ class CommandExecutor:
 
     def _handle_builtin(self, cmd: str) -> Optional[ExecutionSummary]:
         """Intercepts built-ins like cd, clear, cls."""
+        # Multi-line commands/scripts must bypass single-line built-in interception
+        # to prevent cmd.split() from collapsing lines into space-separated arguments.
+        if "\n" in cmd:
+            return None
+
         parts = cmd.split()
         if not parts:
             return None
@@ -220,7 +225,12 @@ class CommandExecutor:
             args = [exe, "-NoLogo", "-Command", cmd]
         elif shell == "cmd":
             exe = self.shell_path if self.shell_path and Path(self.shell_path).exists() else "cmd.exe"
-            args = [exe, "/c", cmd]
+            effective_cmd = (
+                " & ".join(line.strip() for line in cmd.splitlines() if line.strip())
+                if "\n" in cmd
+                else cmd
+            )
+            args = [exe, "/c", effective_cmd]
         else:
             # Unix shells (bash, zsh, fish, sh)
             exe = self.shell_path if self.shell_path and Path(self.shell_path).exists() else "/bin/sh"

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/core/plugin/catalog.py

@@ -53,12 +53,15 @@ def _resolve_catalog_paths():
     if workspace_catalog not in paths:
         paths.append(workspace_catalog)
 
-    # 2. Global runtime data directory
-    global_catalog = get_kapsel_dir() / "plugins_catalog.json"
-    paths.append(global_catalog)
-
+    # 3. Global runtime plugins directory
     global_in_plugins = get_kapsel_dir() / "plugins" / "catalog.json"
-    paths.append(global_in_plugins)
+    if global_in_plugins not in paths:
+        paths.append(global_in_plugins)
+
+    # 4. Global root catalog fallback
+    global_root = get_kapsel_dir() / "catalog.json"
+    if global_root not in paths:
+        paths.append(global_root)
 
     return paths
 
@@ -267,13 +270,13 @@ def update_plugin_catalog(console: Optional[Console] = None) -> Dict[str, str]:
         except Exception as e:
             con.print(f"[yellow]Warning: Failed to write {target_file}:[/] {e}")
 
-    # Also save to global data directory cache
-    global_cache = get_kapsel_dir() / "plugins_catalog.json"
+    # Also save to global data directory catalog.json
+    global_cache = get_kapsel_dir() / "plugins" / "catalog.json"
     try:
         global_cache.parent.mkdir(parents=True, exist_ok=True)
         global_cache.write_text(json.dumps(rich_catalog, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
     except Exception as e:
-        con.print(f"[yellow]Warning: Failed to write global cache {global_cache}:[/] {e}")
+        con.print(f"[yellow]Warning: Failed to write global catalog {global_cache}:[/] {e}")
 
     flat_catalog = {k: v["description"] for k, v in rich_catalog.items()}
 

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/core/update_check.py

@@ -125,16 +125,7 @@ def get_pypi_upgrade_notice() -> Optional[str]:
             return latest_ver
         return None
 
-    # If no cache exists, launch a quick worker thread with a fast join limit
-    worker = threading.Thread(target=_background_fetch_worker, daemon=True)
-    worker.start()
-    worker.join(timeout=0.6)
-
-    # Re-check cache after fast join
-    cached_after = _read_cached_info()
-    if cached_after is not None:
-        latest_ver = str(cached_after.get("latest_version", ""))
-        if parse_semver(latest_ver) > parse_semver(CURRENT_KAPSEL_VERSION):
-            return latest_ver
-
+    # If no cache exists, launch worker asynchronously in the background without blocking startup
+    threading.Thread(target=_background_fetch_worker, daemon=True).start()
     return None
+

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel/ui/prompt.py

@@ -187,12 +187,13 @@ class BlockRoamingController:
 
     def enter_roaming(self, buffer) -> None:
         blocks = self.get_blocks()
+        self.is_active = True
+        self.saved_buffer_text = buffer.text
         if not blocks:
+            self.current_index = -1
             self.status_msg = "No command blocks in session history."
             return
 
-        self.is_active = True
-        self.saved_buffer_text = buffer.text
         self.current_index = len(blocks) - 1
         self.status_msg = ""
         self._sync_buffer_to_block(buffer)
@@ -467,21 +468,10 @@ def create_key_bindings(
     @kb.add("c-b")
     def _(event: KeyPressEvent) -> None:
         """
-        Ctrl+B: Always opens Block Navigator / Roaming,
-        allowing the user to roam across all blocks even if blocks are running in background.
-        Pressing Enter on a running block inside the navigator enters the live sub-terminal.
+        Ctrl+B: Toggles inline Block Roaming Mode directly in the prompt line,
+        without launching a disruptive full-screen viewport.
         """
-        from prompt_toolkit.application.run_in_terminal import in_terminal
-        from kapsel.ui.viewport import run_block_viewport_async
-
-        async def _launch() -> None:
-            async with in_terminal():
-                cmd = await run_block_viewport_async()
-                if cmd is not None:
-                    event.current_buffer.text = cmd
-                    event.current_buffer.cursor_position = len(cmd)
-
-        event.app.create_background_task(_launch())
+        roam_ctrl.toggle(event.current_buffer)
 
     @kb.add("up", filter=is_roaming)
     @kb.add("k", filter=is_roaming)

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapsel-cli
-Version: 0.6.3
+Version: 0.7.2
 Summary: Next-generation cross-platform terminal capsule & ergonomic shell multiplexer with context-aware command translation and 1,000+ CLI completions.
 Author-email: MrEiu <k648888@vip.qq.com>
 License: MIT

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/kapsel_cli.egg-info/SOURCES.txt

@@ -92,12 +92,16 @@ kapsel_cli.egg-info/entry_points.txt
 kapsel_cli.egg-info/requires.txt
 kapsel_cli.egg-info/top_level.txt
 tests/test_add_concurrent.py
+tests/test_ai_spec_sanitizer.py
 tests/test_block_system.py
 tests/test_carapace_installer.py
 tests/test_config.py
+tests/test_ctrl_b_roaming.py
 tests/test_dir_nav.py
 tests/test_history.py
 tests/test_i18n.py
+tests/test_kp_enhanced.py
+tests/test_multiline_passthrough.py
 tests/test_plugin_ai.py
 tests/test_plugin_alias.py
 tests/test_plugin_autopilot.py
@@ -107,6 +111,8 @@ tests/test_plugin_fetcher.py
 tests/test_plugin_help.py
 tests/test_plugin_init.py
 tests/test_plugin_install.py
+tests/test_plugin_install_batch.py
+tests/test_plugin_kssh.py
 tests/test_plugin_lang.py
 tests/test_plugin_mend.py
 tests/test_plugin_portal.py

{kapsel_cli-0.6.3 → kapsel_cli-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kapsel-cli"
-version = "0.6.3"
+version = "0.7.2"
 description = "Next-generation cross-platform terminal capsule & ergonomic shell multiplexer with context-aware command translation and 1,000+ CLI completions."
 readme = "README.md"
 requires-python = ">=3.9"