kapsel-cli 0.5.4__tar.gz → 0.5.7__tar.gz

{kapsel_cli-0.5.4 → kapsel_cli-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapsel-cli
-Version: 0.5.4
+Version: 0.5.7
 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.5.4 → kapsel_cli-0.5.7}/kapsel/__init__.py

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

{kapsel_cli-0.5.4 → kapsel_cli-0.5.7}/kapsel/cli.py

@@ -48,6 +48,11 @@ def main(args: Optional[List[str]] = None) -> int:
             )
         return result.execution.exit_code
 
+    # Handle 'kapsel restart'
+    if clean_args and clean_args[0] == "restart":
+        from kapsel.completion.kps.builtins.restart import handle_restart
+        return handle_restart()
+
     # If positional subcommands passed (e.g. kapsel toggle, kapsel status, kapsel help, kapsel add, kapsel config, kapsel datadir)
     if clean_args:
         engine = DualStateEngine()
@@ -103,6 +108,10 @@ def main(args: Optional[List[str]] = None) -> int:
             console.print("[dim]Exited Kapsel.[/]")
             break
 
+        if normalized in ("restart", "kapsel restart", "reload"):
+            from kapsel.completion.kps.builtins.restart import handle_restart
+            return handle_restart(console=console)
+
         try:
             result = engine.dispatch(user_input)
             if engine.config.enable_card_border and not result.execution.is_builtin:

{kapsel_cli-0.5.4 → kapsel_cli-0.5.7}/kapsel/completion/kps/builtins/__init__.py

@@ -215,3 +215,13 @@ def register_builtins(registry: "KpsCommandRegistry") -> None:
         scope="system",
     )
 
+    # 12. restart (Re-launch Kapsel interactive shell)
+    from kapsel.completion.kps.builtins.restart import handle_restart_command
+    registry.register(
+        name="restart",
+        handler=handle_restart_command,
+        help_text="Cleanly restart Kapsel interactive shell session",
+        usage="kapsel restart",
+        scope="system",
+    )
+

kapsel_cli-0.5.7/kapsel/completion/kps/builtins/add.py

@@ -0,0 +1,483 @@
+"""
+Kapsel System Command: 'kapsel add <plugin_name...>'.
+Enables and registers plugins into the Kapsel environment.
+Supports 4-thread concurrent installation, multi-selection CLI arguments,
+and interactive checkbox multi-selection menu.
+All comments and descriptions are in English.
+"""
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import importlib.util
+from pathlib import Path
+import shutil
+import sys
+import threading
+from typing import List, Optional, Set, Tuple
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from kapsel.storage.config import get_kapsel_dir, load_config, update_config_value
+from kapsel.ui.banner import ensure_utf8_io
+
+# Mutex locks to ensure thread-safe console output and atomic config updates
+_CONFIG_LOCK = threading.Lock()
+_CONSOLE_LOCK = threading.Lock()
+
+
+def _install_single_plugin(
+    target_raw: str,
+    con: Console,
+    is_dev: bool = False,
+    is_batch: bool = False,
+) -> Tuple[bool, str]:
+    """
+    Installs a single plugin by name or path:
+    1. Resolves source directory (dev local, user global, or remote fetch).
+    2. Copies to user global plugins directory.
+    3. Adds to config.yaml enabled plugins list in thread-safe manner.
+    4. Triggers declarative tools.yaml installer or legacy install.py.
+    Returns (success: bool, message: str).
+    """
+    global_plugins_dir = get_kapsel_dir() / "plugins"
+    global_plugins_dir.mkdir(parents=True, exist_ok=True)
+
+    source_path = Path(target_raw).expanduser()
+    has_path_qualifier = any(sep in target_raw for sep in ("/", "\\")) or target_raw.startswith(".")
+
+    if (has_path_qualifier or is_dev) and source_path.exists() and source_path.is_dir():
+        target_name = source_path.name.lower()
+        dest_plugin_dir = global_plugins_dir / target_name
+
+        if not (source_path / "__init__.py").exists():
+            err = f"Source directory '{source_path}' does not contain '__init__.py'."
+            with _CONSOLE_LOCK:
+                con.print(f"[bold #f43f5e]Error:[/] {err}")
+            return False, err
+
+        shutil.copytree(source_path, dest_plugin_dir, dirs_exist_ok=True)
+        plugin_dir = dest_plugin_dir
+    else:
+        target_name = target_raw.lower()
+        dest_plugin_dir = global_plugins_dir / target_name
+        dev_plugin_dir = Path.cwd() / "plugins" / target_name
+
+        if is_dev and dev_plugin_dir.exists() and dev_plugin_dir.is_dir() and (dev_plugin_dir / "__init__.py").exists():
+            shutil.copytree(dev_plugin_dir, dest_plugin_dir, dirs_exist_ok=True)
+            plugin_dir = dest_plugin_dir
+        elif dest_plugin_dir.exists() and dest_plugin_dir.is_dir():
+            plugin_dir = dest_plugin_dir
+        else:
+            from kapsel.core.plugin.fetcher import fetch_plugin_from_remote
+            if fetch_plugin_from_remote(target_name, dest_plugin_dir, con):
+                plugin_dir = dest_plugin_dir
+            else:
+                err = f"Plugin '{target_name}' could not be installed."
+                with _CONSOLE_LOCK:
+                    con.print(f"[bold #f43f5e]Error:[/] {err}")
+                    if not is_batch:
+                        con.print(f"[dim]Expected location:[/] {dest_plugin_dir}")
+                        con.print("[dim]To install a custom plugin, specify its local path or place it into your global plugins directory.[/]\n")
+                return False, err
+
+    if not (plugin_dir / "__init__.py").exists():
+        err = f"Plugin directory '{plugin_dir}' does not contain a valid '__init__.py'."
+        with _CONSOLE_LOCK:
+            con.print(f"[bold #f43f5e]Error:[/] {err}")
+        return False, err
+
+    # Thread-safe config.yaml update
+    with _CONFIG_LOCK:
+        cfg = load_config()
+        current_enabled = cfg.enabled_plugins
+        if target_name not in current_enabled:
+            new_enabled = current_enabled + [target_name]
+            update_config_value("plugins", "enabled", new_enabled)
+
+    # Declarative tool dependency installation via tools.yaml:
+    tools_file = plugin_dir / "tools.yaml"
+    if tools_file.is_file():
+        try:
+            from kapsel.core.tools.installer import install_plugin_tools
+            bin_dir = get_kapsel_dir() / "bin"
+            bin_dir.mkdir(parents=True, exist_ok=True)
+            install_plugin_tools(plugin_dir, console=con, bin_dir=bin_dir)
+        except Exception as e:
+            with _CONSOLE_LOCK:
+                con.print(f"[yellow]Warning: Error installing dependencies from tools.yaml for '{target_name}':[/] {e}")
+
+    # Legacy install.py fallback (if present):
+    install_script = plugin_dir / "install.py"
+    if install_script.exists():
+        try:
+            bin_dir = get_kapsel_dir() / "bin"
+            bin_dir.mkdir(parents=True, exist_ok=True)
+
+            module_name = f"kapsel_installer_{target_name}"
+            spec = importlib.util.spec_from_file_location(module_name, install_script)
+            if spec and spec.loader:
+                installer_mod = importlib.util.module_from_spec(spec)
+                sys.modules[module_name] = installer_mod
+                spec.loader.exec_module(installer_mod)
+                install_fn = getattr(installer_mod, "install", None)
+                if callable(install_fn):
+                    with _CONSOLE_LOCK:
+                        con.print(f"[dim]Running legacy installer for '[#00f0ff]{target_name}[/]'...[/]")
+                    success = install_fn(con, bin_dir)
+                    if not success:
+                        with _CONSOLE_LOCK:
+                            con.print(f"[yellow]Notice: Installation script for '{target_name}' finished with warnings.[/]")
+        except Exception as e:
+            with _CONSOLE_LOCK:
+                con.print(f"[yellow]Warning: Failed to execute legacy installer for '{target_name}':[/] {e}")
+
+    from kapsel.core.plugin.catalog import _extract_plugin_version
+    ver = _extract_plugin_version(plugin_dir)
+
+    msg = f"[bold #10b981]✔ Plugin '[#00f0ff]{target_name}[/]' (v{ver}) successfully added and enabled![/]\n\n"
+    msg += f"[dim]Location: {plugin_dir}[/]"
+    return True, msg
+
+
+def _handle_add_batch_concurrent(
+    targets: List[str],
+    con: Console,
+    is_dev: bool = False,
+    max_workers: int = 4,
+) -> int:
+    """
+    Installs multiple plugins concurrently using a 4-thread worker pool.
+    Synchronizes output and config writing, and displays an aggregated summary table.
+    """
+    total = len(targets)
+    con.print(f"\n[bold #00f0ff]============================================================[/]")
+    con.print(f"[bold #00f0ff]   📦 Kapsel Concurrent Batch Installer ({max_workers} Threads, {total} Plugins)   [/]")
+    con.print(f"[bold #00f0ff]============================================================[/]\n")
+
+    succeeded: List[str] = []
+    failed: List[Tuple[str, str]] = []
+    results_lock = threading.Lock()
+    progress_counter = 0
+    counter_lock = threading.Lock()
+
+    def _worker_task(plugin_name: str) -> Tuple[bool, str, str]:
+        nonlocal progress_counter
+        with counter_lock:
+            progress_counter += 1
+            idx = progress_counter
+
+        with _CONSOLE_LOCK:
+            con.print(f"[bold #00f0ff]━━━ [{idx}/{total}] Adding & Installing: [white]{plugin_name}[/] ━━━[/]")
+
+        try:
+            ok, msg = _install_single_plugin(plugin_name, con, is_dev=is_dev, is_batch=True)
+            with _CONSOLE_LOCK:
+                if ok:
+                    con.print(f"  [bold #10b981]✔ [{plugin_name}] Added & dependencies verified[/]")
+                else:
+                    con.print(f"  [bold #f43f5e]✘ [{plugin_name}] Failed: {msg}[/]")
+            return ok, plugin_name, msg
+        except Exception as e:
+            with _CONSOLE_LOCK:
+                con.print(f"  [bold #f43f5e]✘ [{plugin_name}] Unexpected error:[/] {e}")
+            return False, plugin_name, str(e)
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = {executor.submit(_worker_task, name): name for name in targets}
+        for fut in as_completed(futures):
+            ok, name, msg = fut.result()
+            with results_lock:
+                if ok:
+                    succeeded.append(name)
+                else:
+                    failed.append((name, msg))
+
+    # Single atomic batch configuration sync for enabled_plugins
+    if succeeded:
+        with _CONFIG_LOCK:
+            cfg = load_config()
+            new_enabled = list(dict.fromkeys(cfg.enabled_plugins + succeeded))
+            update_config_value("plugins", "enabled", new_enabled)
+
+    # Summary table
+    table = Table(
+        title=f"[bold #00f0ff]📊 Concurrent Batch Installation Summary ({len(succeeded)}/{total} Succeeded)[/]",
+        border_style="#0891b2",
+    )
+    table.add_column("Plugin", style="#00f0ff", width=16)
+    table.add_column("Status", width=24)
+    table.add_column("Details", style="dim")
+
+    for name in targets:
+        if name in succeeded:
+            table.add_row(name, "[bold #10b981]✔ Installed & Enabled[/]", "Ready")
+        else:
+            err_msg = next((m for (n, m) in failed if n == name), "Failed")
+            table.add_row(name, "[bold #f43f5e]✘ Failed[/]", err_msg[:50])
+
+    con.print("")
+    con.print(table)
+    summary_color = "#10b981" if not failed else "#f59e0b"
+    con.print(f"\n[{summary_color}]Batch Completed:[/] [white]{len(succeeded)} succeeded[/], "
+              f"[{'#f43f5e' if failed else 'white'}]{len(failed)} failed[/].\n")
+
+    return 0 if succeeded else 1
+
+
+def _handle_add_all(con: Console, is_dev: bool = False, max_workers: int = 4) -> int:
+    """
+    Collects all official and dev Kapsel plugins and installs them concurrently across 4 threads.
+    """
+    from kapsel.core.plugin.catalog import load_plugin_catalog_rich, DEFAULT_CATALOG
+    catalog = load_plugin_catalog_rich()
+    if not catalog:
+        catalog = {k: {"description": v} for k, v in DEFAULT_CATALOG.items()}
+
+    plugin_names: Set[str] = set()
+    for k in catalog.keys():
+        if k not in ("update", "all") and not k.startswith(("_", "$")):
+            plugin_names.add(k)
+
+    dev_plugins_dir = Path.cwd() / "plugins"
+    if is_dev and dev_plugins_dir.is_dir():
+        for item in dev_plugins_dir.iterdir():
+            if item.is_dir() and (item / "__init__.py").exists():
+                if item.name.lower() not in ("update", "all"):
+                    plugin_names.add(item.name.lower())
+
+    ordered_plugins = sorted(plugin_names)
+    return _handle_add_batch_concurrent(ordered_plugins, con, is_dev=is_dev, max_workers=max_workers)
+
+
+def _select_plugins_interactive(con: Console, is_dev: bool = False) -> List[str]:
+    """
+    Interactive multi-selection menu for selecting plugins to install.
+    Uses prompt_toolkit checkbox navigation when running in a TTY,
+    with a clean numeric selection fallback.
+    """
+    from kapsel.core.plugin.catalog import load_plugin_catalog_rich, DEFAULT_CATALOG
+    catalog = load_plugin_catalog_rich()
+    if not catalog:
+        catalog = {k: {"description": v} for k, v in DEFAULT_CATALOG.items()}
+
+    plugin_names: Set[str] = set()
+    for k in catalog.keys():
+        if k not in ("update", "all") and not k.startswith(("_", "$")):
+            plugin_names.add(k)
+
+    dev_plugins_dir = Path.cwd() / "plugins"
+    if is_dev and dev_plugins_dir.is_dir():
+        for item in dev_plugins_dir.iterdir():
+            if item.is_dir() and (item / "__init__.py").exists():
+                if item.name.lower() not in ("update", "all"):
+                    plugin_names.add(item.name.lower())
+
+    ordered_plugins = sorted(plugin_names)
+    if not ordered_plugins:
+        con.print("[yellow]No plugins found in catalog.[/]")
+        return []
+
+    cfg = load_config()
+    already_enabled = set(cfg.enabled_plugins)
+
+    con.print("\n[bold #00f0ff]🧩 Kapsel Plugin Multi-Selection Menu[/]")
+    con.print("[dim]Choose plugins to install and enable concurrently (4-Thread Worker Engine).[/]\n")
+
+    if not sys.stdin.isatty():
+        return _select_plugins_numeric_fallback(ordered_plugins, already_enabled, catalog, con)
+
+    try:
+        from prompt_toolkit.application import Application
+        from prompt_toolkit.key_binding import KeyBindings
+        from prompt_toolkit.layout.containers import HSplit, Window
+        from prompt_toolkit.layout.controls import FormattedTextControl
+        from prompt_toolkit.layout.layout import Layout
+        from prompt_toolkit.styles import Style
+
+        cursor_idx = 0
+        selected_set: Set[str] = set()
+        confirmed = [False]
+
+        def get_menu_text():
+            lines = []
+            for i, name in enumerate(ordered_plugins):
+                is_cursor = (i == cursor_idx)
+                is_checked = name in selected_set
+                is_installed = name in already_enabled
+
+                prefix = " ❯ " if is_cursor else "   "
+                checkbox = "[*] " if is_checked else "[ ] "
+                status_tag = " (already enabled)" if is_installed else ""
+                desc = catalog.get(name, {}).get("description", "")
+                if desc and len(desc) > 50:
+                    desc = desc[:48] + "..."
+                desc_str = f" - {desc}" if desc else ""
+
+                line = f"{prefix}{checkbox}{name:<14}{status_tag:<18}{desc_str}\n"
+
+                if is_cursor:
+                    lines.append(("class:selected", line))
+                elif is_checked:
+                    lines.append(("class:checked", line))
+                else:
+                    lines.append(("class:normal", line))
+
+            lines.append(("\nclass:help", " [↑/↓] Navigate  |  [Space] Toggle  |  [a] Toggle All  |  [Enter] Confirm & Install  |  [Esc/q] Cancel\n"))
+            return lines
+
+        kb = KeyBindings()
+
+        @kb.add("up")
+        def _up(event):
+            nonlocal cursor_idx
+            cursor_idx = (cursor_idx - 1) % len(ordered_plugins)
+
+        @kb.add("down")
+        def _down(event):
+            nonlocal cursor_idx
+            cursor_idx = (cursor_idx + 1) % len(ordered_plugins)
+
+        @kb.add("space")
+        def _toggle(event):
+            cur_name = ordered_plugins[cursor_idx]
+            if cur_name in selected_set:
+                selected_set.remove(cur_name)
+            else:
+                selected_set.add(cur_name)
+
+        @kb.add("a")
+        def _toggle_all(event):
+            if len(selected_set) == len(ordered_plugins):
+                selected_set.clear()
+            else:
+                selected_set.update(ordered_plugins)
+
+        @kb.add("enter")
+        def _confirm(event):
+            confirmed[0] = True
+            event.app.exit()
+
+        @kb.add("escape")
+        @kb.add("q")
+        def _cancel(event):
+            confirmed[0] = False
+            event.app.exit()
+
+        style = Style.from_dict({
+            "selected": "bold fg:#00f0ff bg:#1e293b",
+            "checked": "bold fg:#10b981",
+            "normal": "fg:#e2e8f0",
+            "help": "dim fg:#94a3b8",
+        })
+
+        layout = Layout(HSplit([Window(content=FormattedTextControl(get_menu_text))]))
+        app = Application(layout=layout, key_bindings=kb, style=style, full_screen=False)
+        app.run()
+
+        if confirmed[0]:
+            return [name for name in ordered_plugins if name in selected_set]
+        return []
+
+    except Exception:
+        return _select_plugins_numeric_fallback(ordered_plugins, already_enabled, catalog, con)
+
+
+def _select_plugins_numeric_fallback(
+    ordered_plugins: List[str],
+    already_enabled: Set[str],
+    catalog: dict,
+    con: Console,
+) -> List[str]:
+    """Fallback numbered list selection for non-interactive environments."""
+    for idx, name in enumerate(ordered_plugins, 1):
+        status = "[bold #10b981](enabled)[/]" if name in already_enabled else ""
+        desc = catalog.get(name, {}).get("description", "")
+        con.print(f"  [bold cyan][{idx:2d}][/] [white]{name:<14}[/] {status} [dim]{desc[:50]}[/]")
+
+    con.print("")
+    try:
+        raw = input("Enter plugin numbers (comma-separated, e.g. 1, 3, 5), 'all', or 'q' to cancel: ").strip()
+        if raw.lower() in ("q", "quit", "exit", ""):
+            return []
+        if raw.lower() == "all":
+            return ordered_plugins
+
+        selected = []
+        for part in raw.replace(" ", ",").split(","):
+            part = part.strip()
+            if part.isdigit():
+                num = int(part)
+                if 1 <= num <= len(ordered_plugins):
+                    selected.append(ordered_plugins[num - 1])
+        return selected
+    except Exception:
+        return []
+
+
+def handle_add_command(args: List[str], console: Optional[Console] = None) -> int:
+    """
+    Handles 'kapsel add <plugin_name...>' system command.
+    Supports:
+    - Interactive multi-selection: 'kapsel add' or 'kapsel add -i'
+    - Multiple CLI arguments: 'kapsel add portal backup preview'
+    - Comma-separated plugins: 'kapsel add portal,backup,preview'
+    - 4-Thread concurrent execution: 'kapsel add all' or multi-plugins
+    """
+    ensure_utf8_io()
+    con = console or Console(legacy_windows=False)
+    cfg = load_config()
+    is_dev = getattr(cfg, "is_dev", False)
+
+    # 1. Interactive multi-selection mode if no args or explicit interactive flag
+    interactive_flags = {"-i", "--interactive", "--select", "select"}
+    if not args or any(a in interactive_flags for a in args):
+        chosen = _select_plugins_interactive(con, is_dev=is_dev)
+        if not chosen:
+            con.print("[dim]No plugins selected. Operation cancelled.[/]\n")
+            return 0
+        if len(chosen) == 1:
+            success, msg = _install_single_plugin(chosen[0], con, is_dev=is_dev, is_batch=False)
+            if success:
+                con.print(Panel(msg, title="[bold #00f0ff]🔌 Plugin System[/]", border_style="#0891b2", expand=False))
+                return 0
+            return 1
+        return _handle_add_batch_concurrent(chosen, con, is_dev=is_dev, max_workers=4)
+
+    # 2. Parse target plugin names from CLI arguments (supporting spaces and commas)
+    targets: List[str] = []
+    for arg in args:
+        for item in arg.split(","):
+            item_clean = item.strip()
+            if item_clean and item_clean not in interactive_flags:
+                targets.append(item_clean)
+
+    if not targets:
+        con.print("[bold #f43f5e]Error:[/] Please specify plugin name(s) to add.")
+        con.print("[dim]Usage: kapsel add <name...> | all | update | -i (interactive multi-select)[/]\n")
+        return 1
+
+    # 3. Handle 'kapsel add update'
+    if len(targets) == 1 and targets[0].lower() == "update":
+        from kapsel.core.plugin.catalog import update_plugin_catalog, render_catalog_table
+        con.print("[bold #00f0ff]🔄 Scanning repository plugins and updating catalog dictionary...[/]")
+        updated_catalog = update_plugin_catalog(con)
+        render_catalog_table(updated_catalog, con)
+        con.print("[bold #10b981]✔ Plugin catalog and subcommands completion dictionary successfully updated![/]\n")
+        return 0
+
+    # 4. Handle 'kapsel add all'
+    if any(t.lower() == "all" for t in targets):
+        return _handle_add_all(con, is_dev=is_dev, max_workers=4)
+
+    # 5. Handle single plugin installation
+    if len(targets) == 1:
+        success, msg = _install_single_plugin(targets[0], con, is_dev=is_dev, is_batch=False)
+        if success:
+            con.print(Panel(msg, title="[bold #00f0ff]🔌 Plugin System[/]", border_style="#0891b2", expand=False))
+            return 0
+        else:
+            return 1
+
+    # 6. Handle multiple plugins concurrent installation (4 workers)
+    return _handle_add_batch_concurrent(targets, con, is_dev=is_dev, max_workers=4)

kapsel_cli-0.5.7/kapsel/completion/kps/builtins/restart.py

@@ -0,0 +1,74 @@
+"""
+Kapsel Restart Built-in Command.
+Terminates any background tasks, cleanly tears down the active shell state,
+and re-launches the Kapsel interactive shell session.
+All comments and docstrings are in English.
+"""
+
+import os
+from pathlib import Path
+import subprocess
+import sys
+from typing import List, Optional
+
+from rich.console import Console
+
+from kapsel.core.block.registry import get_block_registry
+from kapsel.i18n import _
+from kapsel.storage.logger import logger
+from kapsel.ui.banner import ensure_utf8_io
+
+
+def handle_restart(console: Optional[Console] = None) -> int:
+    """
+    Tears down current Kapsel shell session and immediately spawns a fresh Kapsel session.
+    """
+    ensure_utf8_io()
+    con = console or Console(legacy_windows=False)
+
+    # 1. Cleanly terminate any active background block tasks
+    try:
+        cleaned = get_block_registry().terminate_all_running()
+        if cleaned > 0:
+            con.print(f"[dim]⚡ Cleaned up {cleaned} background block task(s).[/]")
+    except Exception as e:
+        logger.debug(f"Error cleaning background tasks on restart: {e}")
+
+    # 2. Reset active shell marker
+    os.environ.pop("KAPSEL_ACTIVE", None)
+
+    con.print("[bold #00f0ff]🔄 Restarting Kapsel interactive shell...[/]\n")
+
+    # 3. Determine restart command args
+    raw_argv = sys.argv
+    clean_args = [a for a in raw_argv[1:] if a != "restart"]
+
+    target = raw_argv[0]
+    if (
+        target.lower().endswith((".exe", "kapsel"))
+        and Path(target).is_file()
+    ):
+        cmd = [target] + clean_args
+    else:
+        cmd = [sys.executable, "-m", "kapsel"] + clean_args
+
+    # 4. Re-execute process
+    try:
+        if os.name != "nt":
+            # On POSIX, replace the current process image
+            os.execv(cmd[0], cmd)
+        else:
+            # On Windows, launch child and wait synchronously to maintain console ownership
+            code = subprocess.call(cmd)
+            sys.exit(code)
+    except Exception as e:
+        logger.error(f"Failed to restart Kapsel: {e}")
+        con.print(f"[bold red]Failed to restart Kapsel:[/] {e}")
+        return 1
+
+    return 0
+
+
+def handle_restart_command(args: Optional[List[str]] = None, console: Optional[Console] = None) -> int:
+    """CLI handler for 'kapsel restart'."""
+    return handle_restart(console=console)

{kapsel_cli-0.5.4 → kapsel_cli-0.5.7}/kapsel/completion/kps/builtins/status.py

@@ -65,11 +65,15 @@ def handle_status(args: Optional[List[str]] = None, console: Optional[Console] =
         f"[bold #10b981]{branch}[/]" if branch else f"[dim]{none_str}[/]",
     )
 
+    from kapsel.core.update_check import get_pypi_upgrade_notice
+    up_ver = get_pypi_upgrade_notice()
+    up_badge = f" [bold #f59e0b]🚀 upgrade (v{up_ver})[/]" if up_ver else ""
+
     grid.add_row(
         f"📂 {_('Working Dir:')}",
         f"[dim]{cwd_fmt}[/]",
         f"💊 {_('Kapsel Version:')}",
-        f"[bold #00f0ff]v{__version__}[/] (Python {sys.version.split()[0]})",
+        f"[bold #00f0ff]v{__version__}[/]{up_badge} (Python {sys.version.split()[0]})",
     )
 
     theme_name = cfg.theme.get("name", "cyber_dark") if isinstance(cfg.theme, dict) else str(cfg.theme)

kapsel_cli-0.5.7/kapsel/core/tools/__init__.py

@@ -0,0 +1,36 @@
+"""
+Kapsel Core Declarative Tool Dependency Registry & Installer Package.
+Provides centralized access to aggregated tools across plugins and deterministic installation.
+
+All comments and docstrings are in English.
+"""
+
+from .registry import (
+    ToolRegistry,
+    get_registry,
+    get_tool,
+    get_all_tools,
+    get_plugin_tools,
+)
+from .installer import (
+    ToolInstaller,
+    get_kapsel_bin_dir,
+    is_tool_installed,
+    resolve_tool_executable,
+    install_tool,
+    install_plugin_tools,
+)
+
+__all__ = [
+    "ToolRegistry",
+    "get_registry",
+    "get_tool",
+    "get_all_tools",
+    "get_plugin_tools",
+    "ToolInstaller",
+    "get_kapsel_bin_dir",
+    "is_tool_installed",
+    "resolve_tool_executable",
+    "install_tool",
+    "install_plugin_tools",
+]