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

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

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

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

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

@@ -104,11 +104,13 @@ def main(args: Optional[List[str]] = None) -> int:
 
         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)
 

{kapsel_cli-0.5.7 → kapsel_cli-0.6.3}/kapsel/completion/completer.py

@@ -312,6 +312,7 @@ class DualStateCompleter(Completer):
                 ("cd", _("Change directory")),
                 ("clear", _("Clear terminal screen")),
                 ("exit", _("Exit session")),
+                ("restart", _("Cleanly restart Kapsel interactive shell session")),
                 ("git", _("Git version control")),
                 ("docker", _("Docker container platform")),
                 ("scoop", _("Windows command-line installer")),

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

@@ -26,6 +26,40 @@ _CONFIG_LOCK = threading.Lock()
 _CONSOLE_LOCK = threading.Lock()
 
 
+def _check_plugin_already_installed(
+    target_raw: str,
+    is_dev: bool = False,
+) -> Tuple[bool, Optional[str], Optional[Path]]:
+    """
+    Checks if a plugin is already installed on the system by verifying its directory and version.
+    Returns: (is_installed: bool, version: Optional[str], plugin_path: Optional[Path]).
+    """
+    has_path_qualifier = any(sep in target_raw for sep in ("/", "\\")) or target_raw.startswith(".")
+    if has_path_qualifier:
+        p = Path(target_raw).expanduser()
+        target_name = p.name.lower()
+    else:
+        target_name = target_raw.strip().lower()
+
+    from kapsel.core.plugin.catalog import _extract_plugin_version
+
+    # 1. Check user global plugins directory (~/.kapsel/plugins/<name>)
+    global_plugins_dir = get_kapsel_dir() / "plugins"
+    dest_plugin_dir = global_plugins_dir / target_name
+    if dest_plugin_dir.is_dir() and ((dest_plugin_dir / "__init__.py").exists() or (dest_plugin_dir / "plugin.py").exists()):
+        ver = _extract_plugin_version(dest_plugin_dir)
+        return True, ver, dest_plugin_dir
+
+    # 2. Check local workspace dev directory if in dev mode
+    if is_dev:
+        dev_plugin_dir = Path.cwd() / "plugins" / target_name
+        if dev_plugin_dir.is_dir() and ((dev_plugin_dir / "__init__.py").exists() or (dev_plugin_dir / "plugin.py").exists()):
+            ver = _extract_plugin_version(dev_plugin_dir)
+            return True, ver, dev_plugin_dir
+
+    return False, None, None
+
+
 def _install_single_plugin(
     target_raw: str,
     con: Console,
@@ -34,12 +68,26 @@ def _install_single_plugin(
 ) -> 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.
+    1. Checks if the plugin is already installed; if so, skips installation and prompts for upgrade.
+    2. Resolves source directory (dev local, user global, or remote fetch).
+    3. Copies to user global plugins directory.
+    4. Adds to config.yaml enabled plugins list in thread-safe manner.
+    5. Triggers declarative tools.yaml installer or legacy install.py.
     Returns (success: bool, message: str).
     """
+    is_installed, cur_ver, existing_dir = _check_plugin_already_installed(target_raw, is_dev=is_dev)
+    if is_installed:
+        target_name = existing_dir.name.lower() if existing_dir else target_raw.lower()
+        if not is_batch:
+            with _CONFIG_LOCK:
+                cfg = load_config()
+                current_enabled = cfg.enabled_plugins or []
+                if target_name not in current_enabled:
+                    new_enabled = current_enabled + [target_name]
+                    update_config_value("plugins", "enabled", new_enabled)
+        ver_str = f" (v{cur_ver})" if cur_ver else ""
+        return True, f"Plugin '{target_name}' is already installed{ver_str}. To upgrade this plugin, run: kapsel upgrade {target_name}"
+
     global_plugins_dir = get_kapsel_dir() / "plugins"
     global_plugins_dir.mkdir(parents=True, exist_ok=True)
 
@@ -87,13 +135,22 @@ def _install_single_plugin(
             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)
+    # Thread-safe config.yaml update (skip during concurrent batch; batch handler syncs atomically at the end)
+    if not is_batch:
+        with _CONFIG_LOCK:
+            cfg = load_config()
+            current_enabled = cfg.enabled_plugins or []
+            if target_name not in current_enabled:
+                new_enabled = current_enabled + [target_name]
+                update_config_value("plugins", "enabled", new_enabled)
+
+        # Sync Carapace specs for single plugin
+        try:
+            from kapsel.completion.spec_manager import CarapaceSpecManager
+            spec_mgr = CarapaceSpecManager()
+            spec_mgr.sync_specs()
+        except Exception:
+            pass
 
     # Declarative tool dependency installation via tools.yaml:
     tools_file = plugin_dir / "tools.yaml"
@@ -147,14 +204,64 @@ def _handle_add_batch_concurrent(
     max_workers: int = 4,
 ) -> int:
     """
-    Installs multiple plugins concurrently using a 4-thread worker pool.
+    Installs multiple plugins concurrently using an adaptive worker thread pool.
+    Dynamically scales thread count when fewer than 4 plugins need installation.
     Synchronizes output and config writing, and displays an aggregated summary table.
     """
-    total = len(targets)
+    cfg = load_config()
+    already_enabled = set(p.lower() for p in (cfg.enabled_plugins or []))
+
+    # Partition targets into uninstalled vs already-installed
+    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:
+            already_done.append(t_clean)
+        else:
+            uninstalled.append(t_clean)
+
+    uninstalled = list(dict.fromkeys(uninstalled))
+    already_done = list(dict.fromkeys(already_done))
+
+    # Ensure already_done are marked enabled in config.yaml
+    if already_done:
+        with _CONFIG_LOCK:
+            cfg = load_config()
+            current_enabled = cfg.enabled_plugins or []
+            to_enable = [p.lower() for p in already_done if p.lower() not in current_enabled]
+            if to_enable:
+                update_config_value("plugins", "enabled", current_enabled + to_enable)
+
+    if not uninstalled:
+        con.print(f"\n[bold #10b981]✔ All specified plugins ({len(already_done)}) are already installed.[/]")
+        con.print("[dim]Notice: To upgrade installed plugins, please run:[/] [bold white]kapsel upgrade[/]\n")
+        return 0
+
+    # If only 1 plugin actually needs installation, install directly without worker pool
+    if len(uninstalled) == 1:
+        if already_done:
+            con.print(f"[dim]Notice: {', '.join(already_done)} already installed/enabled.[/]")
+        success, msg = _install_single_plugin(uninstalled[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
+
+    total = len(uninstalled)
+    # Dynamically adapt thread count: never spawn more workers than actual uninstalled plugins
+    actual_workers = max(1, min(max_workers, total))
+
     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]   📦 Kapsel Concurrent Batch Installer ({actual_workers} Threads, {total} Plugins)   [/]")
     con.print(f"[bold #00f0ff]============================================================[/]\n")
 
+    if already_done:
+        con.print(f"[dim]Notice: {len(already_done)} plugin(s) already installed (skipped): {', '.join(already_done)}[/]\n")
+
     succeeded: List[str] = []
     failed: List[Tuple[str, str]] = []
     results_lock = threading.Lock()
@@ -183,8 +290,8 @@ def _handle_add_batch_concurrent(
                 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}
+    with ThreadPoolExecutor(max_workers=actual_workers) as executor:
+        futures = {executor.submit(_worker_task, name): name for name in uninstalled}
         for fut in as_completed(futures):
             ok, name, msg = fut.result()
             with results_lock:
@@ -197,9 +304,17 @@ def _handle_add_batch_concurrent(
     if succeeded:
         with _CONFIG_LOCK:
             cfg = load_config()
-            new_enabled = list(dict.fromkeys(cfg.enabled_plugins + succeeded))
+            new_enabled = list(dict.fromkeys((cfg.enabled_plugins or []) + succeeded))
             update_config_value("plugins", "enabled", new_enabled)
 
+        # Sync Carapace specs for newly enabled plugins
+        try:
+            from kapsel.completion.spec_manager import CarapaceSpecManager
+            spec_mgr = CarapaceSpecManager()
+            spec_mgr.sync_specs()
+        except Exception:
+            pass
+
     # Summary table
     table = Table(
         title=f"[bold #00f0ff]📊 Concurrent Batch Installation Summary ({len(succeeded)}/{total} Succeeded)[/]",
@@ -209,25 +324,31 @@ def _handle_add_batch_concurrent(
     table.add_column("Status", width=24)
     table.add_column("Details", style="dim")
 
-    for name in targets:
+    for name in uninstalled:
         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])
 
+    for name in already_done:
+        table.add_row(name, "[dim #10b981]✔ Already Installed[/]", "Skipped (Use 'kapsel upgrade' to update)")
+
     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")
+              f"[{'#f43f5e' if failed else 'white'}]{len(failed)} failed[/], "
+              f"[dim]{len(already_done)} already installed[/].\n")
 
-    return 0 if succeeded else 1
+    return 0 if succeeded or (not failed and already_done) 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.
+    Collects all uninstalled official and dev Kapsel plugins and installs them concurrently.
+    Dynamically scales thread count when fewer than 4 plugins need installation.
+    Filters out any already-installed plugins and directs user to 'kapsel upgrade'.
     """
     from kapsel.core.plugin.catalog import load_plugin_catalog_rich, DEFAULT_CATALOG
     catalog = load_plugin_catalog_rich()
@@ -247,7 +368,48 @@ def _handle_add_all(con: Console, is_dev: bool = False, max_workers: int = 4) ->
                     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)
+
+    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
+    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:
+            already_installed.append(p)
+        else:
+            uninstalled.append(p)
+
+    # Ensure all already_installed are marked enabled in config.yaml
+    if already_installed:
+        with _CONFIG_LOCK:
+            cfg = load_config()
+            current_enabled = cfg.enabled_plugins or []
+            to_enable = [p.lower() for p in already_installed if p.lower() not in current_enabled]
+            if to_enable:
+                update_config_value("plugins", "enabled", current_enabled + to_enable)
+
+    if not uninstalled:
+        con.print(f"\n[bold #10b981]✔ All official plugins ({len(already_installed)}) are already installed.[/]")
+        con.print("[dim]Notice: To check or upgrade installed plugins, please run:[/] [bold white]kapsel upgrade[/]\n")
+        return 0
+
+    con.print(f"[dim]Skipped {len(already_installed)} already-installed plugin(s). To upgrade, run: kapsel upgrade[/]")
+    con.print(f"[dim]Installing {len(uninstalled)} new plugin(s) ({len(ordered_plugins)} total in catalog).[/]\n")
+
+    # If only 1 uninstalled plugin, no need for thread pool
+    if len(uninstalled) == 1:
+        success, msg = _install_single_plugin(uninstalled[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
+
+    # When fewer than max_workers (e.g. 2 or 3), dynamically adapt thread count to len(uninstalled)
+    workers = min(max_workers, len(uninstalled))
+    return _handle_add_batch_concurrent(uninstalled, con, is_dev=is_dev, max_workers=workers)
 
 
 def _select_plugins_interactive(con: Console, is_dev: bool = False) -> List[str]:
@@ -442,7 +604,7 @@ def handle_add_command(args: List[str], console: Optional[Console] = None) -> in
                 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)
+        return _handle_add_batch_concurrent(chosen, con, is_dev=is_dev, max_workers=min(4, len(chosen)))
 
     # 2. Parse target plugin names from CLI arguments (supporting spaces and commas)
     targets: List[str] = []
@@ -472,6 +634,23 @@ def handle_add_command(args: List[str], console: Optional[Console] = None) -> in
 
     # 5. Handle single plugin installation
     if len(targets) == 1:
+        target = targets[0]
+        has_path_qualifier = any(sep in target for sep in ("/", "\\")) or target.startswith(".")
+        target_name = Path(target).name.lower() if has_path_qualifier else target.lower()
+
+        is_installed, cur_ver, _ = _check_plugin_already_installed(target, is_dev=is_dev)
+        if is_installed:
+            with _CONFIG_LOCK:
+                cfg = load_config()
+                current_enabled = cfg.enabled_plugins or []
+                if target_name not in current_enabled:
+                    new_enabled = current_enabled + [target_name]
+                    update_config_value("plugins", "enabled", new_enabled)
+            ver_str = f" (v{cur_ver})" if cur_ver else ""
+            con.print(f"\n[bold #f59e0b]●[/] Plugin '[bold #00f0ff]{target_name}[/]' is already installed{ver_str}.")
+            con.print(f"[dim]To upgrade this plugin, please run:[/] [bold white]kapsel upgrade {target_name}[/]\n")
+            return 0
+
         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))
@@ -479,5 +658,5 @@ def handle_add_command(args: List[str], console: Optional[Console] = None) -> in
         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)
+    # 6. Handle multiple plugins concurrent installation (adapted worker count)
+    return _handle_add_batch_concurrent(targets, con, is_dev=is_dev, max_workers=min(4, len(targets)))

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

@@ -68,12 +68,14 @@ def handle_status(args: Optional[List[str]] = None, console: Optional[Console] =
     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 ""
+    venv = detector.get_virtual_env()
+    venv_badge = f" [bold #10b981]({venv})[/]" if venv else ""
 
     grid.add_row(
         f"📂 {_('Working Dir:')}",
         f"[dim]{cwd_fmt}[/]",
         f"💊 {_('Kapsel Version:')}",
-        f"[bold #00f0ff]v{__version__}[/]{up_badge} (Python {sys.version.split()[0]})",
+        f"[bold #00f0ff]v{__version__}[/]{up_badge} (Python {sys.version.split()[0]}){venv_badge}",
     )
 
     theme_name = cfg.theme.get("name", "cyber_dark") if isinstance(cfg.theme, dict) else str(cfg.theme)

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

@@ -9,6 +9,7 @@ All comments and descriptions are in English.
 Default interface language is English with i18n support.
 """
 
+from concurrent.futures import ThreadPoolExecutor, as_completed
 import importlib.util
 import json
 import os
@@ -17,6 +18,7 @@ import re
 import shutil
 import subprocess
 import sys
+import threading
 from typing import Any, Dict, List, Optional, Tuple
 import urllib.request
 from rich.console import Console
@@ -35,6 +37,8 @@ from kapsel.ui.banner import ensure_utf8_io
 
 ensure_utf8_io()
 
+_CONSOLE_LOCK = threading.Lock()
+
 # Remote endpoints for Kapsel Core releases
 KAPSEL_GITHUB_RELEASE_API = "https://api.github.com/repos/MrEiu/Kapsel/releases/latest"
 KAPSEL_GITHUB_RELEASE_MIRROR_API = "https://ghproxy.net/https://api.github.com/repos/MrEiu/Kapsel/releases/latest"
@@ -260,28 +264,58 @@ def check_plugins_update(
     return results
 
 
-def run_plugin_post_install(plugin_dir: Path, con: Console) -> bool:
+def install_plugin_dependencies(plugin_dir: Path, con: Console) -> bool:
     """
-    Executes the plugin's install.py script if present after update.
-    Returns True on success or if no installer exists.
+    Installs missing declarative tools from tools.yaml and/or runs legacy install.py.
+    Ensures any uninstalled dependencies are properly installed during upgrade.
     """
-    install_script = plugin_dir / "install.py"
-    if not install_script.is_file():
-        return True
+    all_ok = True
+    target_name = plugin_dir.name
 
-    con.print(f"  [dim]Running post-install setup for [bold #00f0ff]{plugin_dir.name}[/]...[/]")
-    try:
-        spec = importlib.util.spec_from_file_location(f"kapsel_install_{plugin_dir.name}", install_script)
-        if spec and spec.loader:
-            mod = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(mod)
-            if hasattr(mod, "install"):
-                bin_dir = get_kapsel_dir() / "bin"
-                res = mod.install(con, bin_dir)
-                return bool(res)
-    except Exception as e:
-        con.print(f"  [yellow]Notice: Post-install setup warning for {plugin_dir.name}: {e}[/]")
-    return True
+    # 1. Declarative tool dependencies 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)
+            with _CONSOLE_LOCK:
+                con.print(f"  [dim]Checking tool dependencies for '[bold #00f0ff]{target_name}[/]' (tools.yaml)...[/]")
+            ok = install_plugin_tools(plugin_dir, console=con, bin_dir=bin_dir)
+            if not ok:
+                all_ok = False
+        except Exception as e:
+            with _CONSOLE_LOCK:
+                con.print(f"  [yellow]Warning: Error installing tools.yaml dependencies for '{target_name}':[/] {e}")
+            all_ok = False
+
+    # 2. Legacy install.py script (if present)
+    install_script = plugin_dir / "install.py"
+    if install_script.is_file():
+        try:
+            with _CONSOLE_LOCK:
+                con.print(f"  [dim]Running post-install setup for '[bold #00f0ff]{target_name}[/]' (install.py)...[/]")
+            spec = importlib.util.spec_from_file_location(f"kapsel_install_{target_name}", install_script)
+            if spec and spec.loader:
+                mod = importlib.util.module_from_spec(spec)
+                sys.modules[f"kapsel_install_{target_name}"] = mod
+                spec.loader.exec_module(mod)
+                if hasattr(mod, "install"):
+                    bin_dir = get_kapsel_dir() / "bin"
+                    bin_dir.mkdir(parents=True, exist_ok=True)
+                    res = mod.install(con, bin_dir)
+                    if not res:
+                        all_ok = False
+        except Exception as e:
+            with _CONSOLE_LOCK:
+                con.print(f"  [yellow]Notice: Post-install setup warning for '{target_name}':[/] {e}")
+            all_ok = False
+
+    return all_ok
+
+
+# Alias for backward compatibility
+run_plugin_post_install = install_plugin_dependencies
 
 
 def prompt_user_choice(prompt_msg: str, default: str = "y") -> str:
@@ -364,7 +398,7 @@ def handle_upgrade(args: List[str], console: Optional[Console] = None) -> int:
         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):
-            run_plugin_post_install(dest_dir, con)
+            install_plugin_dependencies(dest_dir, con)
             try:
                 from kapsel.completion.spec_manager import CarapaceSpecManager
                 CarapaceSpecManager().sync_specs()
@@ -490,17 +524,53 @@ def handle_upgrade(args: List[str], console: Optional[Console] = None) -> int:
             con.print(f"[dim]{_('Cancelled.')}[/]\n")
             return 0
 
-    # Apply plugin updates
-    success_count = 0
-    for p in upgradable_plugins:
-        con.print(f"[dim]{_('Updating')} [bold #00f0ff]{p['name']}[/] {_('to')} v{p['latest']}...[/]")
-        dest_dir = p["dir"] or (get_kapsel_dir() / "plugins" / p["name"])
-        if fetch_plugin_from_remote(p["name"], dest_dir, con):
-            run_plugin_post_install(dest_dir, con)
-            success_count += 1
-            con.print(f"  [bold #10b981]✔ {_('Updated')} {p['name']} {_('to')} v{p['latest']}[/]")
+    # Apply plugin updates concurrently
+    actual_workers = max(1, min(4, len(upgradable_plugins)))
+    con.print(f"\n[bold #00f0ff]━━━ {_('Updating')} {len(upgradable_plugins)} {_('plugin(s) concurrently')} ({actual_workers} {_('Threads')}) ━━━[/]\n")
+
+    succeeded_plugins: List[str] = []
+    failed_plugins: List[Tuple[str, str]] = []
+    results_lock = threading.Lock()
+
+    def _upgrade_worker(p_info: Dict[str, Any]) -> Tuple[bool, str, str]:
+        name = p_info["name"]
+        latest_ver = p_info["latest"]
+        dest_dir = p_info["dir"] or (get_kapsel_dir() / "plugins" / name)
+
+        with _CONSOLE_LOCK:
+            con.print(f"[dim]{_('Updating')} [bold #00f0ff]{name}[/] {_('to')} v{latest_ver}...[/]")
+
+        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}"
+            else:
+                with _CONSOLE_LOCK:
+                    con.print(f"  [bold #f43f5e]✘ {_('Failed to update')} {name}[/]")
+                return False, name, "Download failed"
+        except Exception as ex:
+            with _CONSOLE_LOCK:
+                con.print(f"  [bold #f43f5e]✘ {_('Error updating')} {name}:[/] {ex}")
+            return False, name, str(ex)
+
+    if len(upgradable_plugins) == 1:
+        ok, name, detail = _upgrade_worker(upgradable_plugins[0])
+        if ok:
+            succeeded_plugins.append(name)
         else:
-            con.print(f"  [bold #f43f5e]✘ {_('Failed to update')} {p['name']}[/]")
+            failed_plugins.append((name, detail))
+    else:
+        with ThreadPoolExecutor(max_workers=actual_workers) as executor:
+            futures = {executor.submit(_upgrade_worker, p): p["name"] for p in upgradable_plugins}
+            for fut in as_completed(futures):
+                ok, name, detail = fut.result()
+                with results_lock:
+                    if ok:
+                        succeeded_plugins.append(name)
+                    else:
+                        failed_plugins.append((name, detail))
 
     # Re-sync completion specifications
     try:
@@ -509,5 +579,5 @@ def handle_upgrade(args: List[str], console: Optional[Console] = None) -> int:
     except Exception:
         pass
 
-    con.print(f"\n[bold #10b981]✨ {_('Successfully updated')} {success_count}/{len(upgradable_plugins)} {_('plugin(s)!')}[/]\n")
-    return 0
+    con.print(f"\n[bold #10b981]✨ {_('Successfully updated')} {len(succeeded_plugins)}/{len(upgradable_plugins)} {_('plugin(s)!')}[/]\n")
+    return 0 if not failed_plugins else 1

{kapsel_cli-0.5.7 → kapsel_cli-0.6.3}/kapsel/completion/spec_manager.py

@@ -121,7 +121,6 @@ CORE_SYSTEM_COMMANDS: List[Dict[str, Any]] = [
     },
     {
         "name": "upgrade",
-        "aliases": ["update"],
         "description": "Check and upgrade Kapsel Core and official plugins with release notes",
         "flags": {
             "-c, --check": "Check for updates without downloading or installing",

{kapsel_cli-0.5.7 → kapsel_cli-0.6.3}/kapsel/core/detector.py

@@ -158,5 +158,37 @@ class EnvironmentDetector:
         except ValueError:
             return str(p)
 
+    def get_virtual_env(self) -> Optional[str]:
+        """
+        Detects active Python virtual environment or Conda environment.
+        Returns the environment name (e.g. 'base', 'myenv', '.venv') or None if not active.
+        """
+        # 1. Conda environment
+        conda_env = os.environ.get("CONDA_DEFAULT_ENV")
+        if conda_env:
+            clean = conda_env.strip()
+            if clean:
+                return clean
+
+        # 2. VIRTUAL_ENV_PROMPT (Python 3.11+ custom venv prompt)
+        venv_prompt = os.environ.get("VIRTUAL_ENV_PROMPT")
+        if venv_prompt:
+            clean = venv_prompt.strip().strip("()").strip()
+            if clean:
+                return clean
+
+        # 3. Standard VIRTUAL_ENV path
+        virtual_env = os.environ.get("VIRTUAL_ENV")
+        if virtual_env:
+            name = Path(virtual_env).name.strip()
+            if name:
+                return name
+
+        # 4. In-process virtual environment check (sys.prefix != sys.base_prefix)
+        if hasattr(sys, "base_prefix") and sys.prefix != sys.base_prefix:
+            return Path(sys.prefix).name.strip()
+
+        return None
+
 
 detector = EnvironmentDetector()

{kapsel_cli-0.5.7 → kapsel_cli-0.6.3}/kapsel/storage/config.py

@@ -29,6 +29,7 @@ DEFAULT_CONFIG: Dict[str, Any] = {
         "enable_card_border": True,
         "show_git_branch": True,
         "show_shell_badge": True,
+        "show_venv_badge": True,
         "show_timestamp": True,
         "prompt_symbols": {
             "top": "╭─",
@@ -58,7 +59,7 @@ DEFAULT_CONFIG: Dict[str, Any] = {
         "auto_strip_spaces": True,
     },
     "history": {
-        "max_memory_entries": 20,
+        "max_memory_entries": 150,
         "frequency_learning": True,
     },
     "cloud": {
@@ -137,6 +138,9 @@ ui:
   # 提示行是否显示当前外层 Shell 徽章 (如 [pwsh], [cmd])
   show_shell_badge: true
 
+  # 提示行是否显示当前 Python / Conda 虚拟环境徽标 (如 (base), (.venv))
+  show_venv_badge: true
+
   # 提示行是否显示当前执行时间戳
   show_timestamp: true
 
@@ -271,7 +275,7 @@ class KapselConfig:
 
     @property
     def history_entries(self) -> int:
-        return int(self.raw.get("history", {}).get("max_memory_entries", 20))
+        return int(self.raw.get("history", {}).get("max_memory_entries", 150))
 
     @property
     def enabled_plugins(self) -> List[str]: