kapsel-cli 0.5.2__tar.gz → 0.5.3__tar.gz

{kapsel_cli-0.5.2 → kapsel_cli-0.5.3}/PKG-INFO

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

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

{kapsel_cli-0.5.2 → kapsel_cli-0.5.3}/kapsel/completion/kps/builtins/__init__.py

@@ -153,7 +153,13 @@ def register_builtins(registry: "KpsCommandRegistry") -> None:
     # 9. upgrade & update (Kapsel Core & official plugins)
     from kapsel.completion.kps.builtins.upgrade import handle_upgrade
 
+    # Merge catalog entries with locally installed plugins so enable/disable/upgrade
+    # completions reflect the actual filesystem state (e.g. workspace dev plugins).
+    from kapsel.completion.kps.builtins.plugin_switch import get_all_installed_plugins
     plugin_subcommands = {k: v for k, v in add_subcommands.items() if k != "update"}
+    for p in get_all_installed_plugins():
+        if p not in plugin_subcommands and p not in ("update", "all"):
+            plugin_subcommands[p] = f"Plugin: {p}"
 
     registry.register(
         name="upgrade",

{kapsel_cli-0.5.2 → kapsel_cli-0.5.3}/kapsel/completion/kps/builtins/plugin_switch.py

@@ -36,17 +36,69 @@ def get_all_installed_plugins() -> List[str]:
     return sorted(installed)
 
 
+def _render_plugin_status_table(con: Console) -> None:
+    """Renders a full overview table of all installed plugins with enabled/disabled status."""
+    from rich.table import Table
+    from kapsel.core.plugin.catalog import _extract_plugin_version, _extract_plugin_description
+    from kapsel.storage.config import get_kapsel_dir
+    from pathlib import Path
+
+    cfg = load_config()
+    enabled_set = set(p.lower() for p in (cfg.enabled_plugins or []))
+    all_installed = get_all_installed_plugins()
+
+    table = Table(
+        title="[bold #00f0ff]🧩 Kapsel Plugin Status Overview[/]",
+        border_style="#0891b2",
+        header_style="bold #00f0ff",
+        show_header=True,
+        expand=False,
+    )
+    table.add_column("Plugin", style="bold #a855f7", width=16)
+    table.add_column("Version", style="dim #9ca3af", width=10)
+    table.add_column("Status", width=14)
+    table.add_column("Description", style="#e4e4e7")
+
+    for name in all_installed:
+        # Resolve version & description from actual plugin dir
+        ver, desc = "0.1.0", f"Plugin: {name}"
+        for base in (Path.cwd() / "plugins", get_kapsel_dir() / "plugins"):
+            p_dir = base / name
+            if p_dir.is_dir():
+                v = _extract_plugin_version(p_dir)
+                d = _extract_plugin_description(p_dir)
+                if v:
+                    ver = v
+                if d:
+                    desc = d
+                break
+
+        if not enabled_set or name in enabled_set:
+            status = "[bold #10b981]● Enabled[/]"
+        else:
+            status = "[dim #6b7280]○ Disabled[/]"
+
+        table.add_row(name, f"v{ver}", status, desc)
+
+    con.print()
+    con.print(table)
+    con.print(
+        f"[dim]Run [bold #00f0ff]kapsel enable <plugin>[/] or "
+        f"[bold #f43f5e]kapsel disable <plugin>[/] to toggle.[/]\n"
+    )
+
+
 def handle_enable_plugin(args: List[str], console: Optional[Console] = None) -> int:
     """
     Enables one or more installed Kapsel plugins.
     Usage:
       kapsel enable <plugin_name>
+      kapsel enable              (shows full plugin status table)
     """
     con = console or Console(legacy_windows=False)
     if not args:
-        con.print("[bold #f43f5e]Error:[/] Please specify a plugin name to enable.")
-        con.print("[dim]Usage: kapsel enable <plugin_name> (e.g. kapsel enable shore)[/]\n")
-        return 1
+        _render_plugin_status_table(con)
+        return 0
 
     target = args[0].strip().lower()
     cfg = load_config()
@@ -88,13 +140,63 @@ def handle_enable_plugin(args: List[str], console: Optional[Console] = None) ->
     except Exception:
         pass
 
-    rich_catalog = load_plugin_catalog_rich()
-    ver = rich_catalog.get(target, {}).get("version", "0.1.0")
-    con.print(f"[bold #10b981]✔ Successfully enabled plugin '[bold #00f0ff]{target}[/]' (v{ver}).[/]")
-    con.print(f"[dim]You can now run 'kps {target}' or explore its commands.[/]\n")
+    # Build status card
+    from rich.table import Table as _Table
+    from rich.panel import Panel as _Panel
+    from kapsel.core.plugin.catalog import _extract_plugin_version, _extract_plugin_description
+    from pathlib import Path as _Path
+    from kapsel.storage.config import get_kapsel_dir as _get_dir
+
+    # Resolve version & description from actual plugin files first
+    ver, desc = None, None
+    for base in (_Path.cwd() / "plugins", _get_dir() / "plugins"):
+        p_dir = base / target
+        if p_dir.is_dir():
+            ver = _extract_plugin_version(p_dir)
+            desc = _extract_plugin_description(p_dir)
+            break
+    if not ver:
+        ver = load_plugin_catalog_rich().get(target, {}).get("version", "0.1.0")
+    if not desc:
+        desc = load_plugin_catalog_rich().get(target, {}).get("description", f"Plugin: {target}")
+
+    # Collect subcommands from live registry if available
+    subcommands: dict = {}
+    try:
+        from kapsel.completion.kps.registry import get_kps_registry
+        cmd_entry = get_kps_registry().get(target)
+        if cmd_entry:
+            subcommands = cmd_entry.subcommands or {}
+    except Exception:
+        pass
+
+    grid = _Table.grid(padding=(0, 2))
+    grid.add_column(style="bold #a855f7", width=14)
+    grid.add_column(style="#e4e4e7")
+
+    grid.add_row("Plugin:", f"[bold #00f0ff]{target}[/]  [dim]v{ver}[/]")
+    grid.add_row("Description:", desc)
+    grid.add_row("Status:", "[bold #10b981]✔ Enabled[/]")
+    grid.add_row("Run:", f"[bold #38bdf8]kps {target} [dim][command][/][/]")
+
+    if subcommands:
+        grid.add_row("Commands:", "")
+        for sub, sub_desc in list(subcommands.items())[:8]:
+            grid.add_row("", f"  [bold #38bdf8]{sub:<16}[/] [dim]{sub_desc}[/]")
+        if len(subcommands) > 8:
+            grid.add_row("", f"  [dim]... and {len(subcommands) - 8} more[/]")
+
+    con.print(_Panel(
+        grid,
+        title=f"[bold #00f0ff]🔌 Plugin Enabled: {target}[/]",
+        border_style="#0891b2",
+        padding=(1, 2),
+        expand=False,
+    ))
     return 0
 
 
+
 def handle_disable_plugin(args: List[str], console: Optional[Console] = None) -> int:
     """
     Disables one or more active Kapsel plugins.

{kapsel_cli-0.5.2 → kapsel_cli-0.5.3}/kapsel/completion/kps/builtins/status.py

@@ -115,11 +115,26 @@ def handle_status(args: Optional[List[str]] = None, console: Optional[Console] =
         active_plugins = [p.lower() for p in enabled_plugins]
 
     if active_plugins:
+        from kapsel.core.plugin.catalog import _extract_plugin_version
+        from kapsel.storage.config import get_kapsel_dir as _get_dir
+
+        def _get_plugin_version(name: str) -> str:
+            # 1. Try actual plugin directory (workspace dev or global)
+            for base in (Path.cwd() / "plugins", _get_dir() / "plugins"):
+                p = base / name
+                if p.is_dir():
+                    v = _extract_plugin_version(p)
+                    if v and v != "0.1.0":
+                        return v
+            # 2. Fallback to catalog metadata
+            return rich_catalog.get(name, {}).get("version", "0.1.0")
+
         plugin_badges = [
-            f"[bold #00f0ff]{p}[/][dim]@{rich_catalog.get(p, {}).get('version', '0.1.0')}[/]"
+            f"[bold #00f0ff]{p}[/][dim]@{_get_plugin_version(p)}[/]"
             for p in active_plugins
         ]
         plugins_str = ", ".join(plugin_badges)
+
     else:
         plugins_str = f"[dim]{none_str}[/]"
 

{kapsel_cli-0.5.2 → kapsel_cli-0.5.3}/kapsel/core/plugin/catalog.py

@@ -108,7 +108,37 @@ def load_plugin_catalog_rich() -> Dict[str, Dict[str, Any]]:
             except Exception:
                 pass
 
-    # If file not present yet, return default catalog converted to rich format
+    # If file not present yet, try to fetch from remote repository before falling back to defaults
+    try:
+        from kapsel.core.plugin.fetcher import fetch_remote_catalog
+        remote_data = fetch_remote_catalog()
+        if remote_data and isinstance(remote_data, dict):
+            result = {}
+            for k, v in remote_data.items():
+                if k.startswith(("_", "$")):
+                    continue
+                if isinstance(v, dict):
+                    result[k] = {
+                        "version": v.get("version", "0.1.0"),
+                        "description": v.get("description", f"Plugin {k}"),
+                        "changelog": v.get("changelog", ""),
+                    }
+                else:
+                    result[k] = {
+                        "version": "0.1.0",
+                        "description": str(v),
+                        "changelog": "",
+                    }
+            result.setdefault("update", {
+                "version": "0.1.0",
+                "description": "Scan and update available plugin catalog and completion dictionary",
+                "changelog": "Catalog dictionary update scanner.",
+            })
+            return result
+    except Exception:
+        pass
+
+    # Final fallback: built-in DEFAULT_CATALOG (offline / import error)
     return {
         k: {
             "version": "0.2.0" if k in ("alias", "install") else "0.1.0",
@@ -119,6 +149,7 @@ def load_plugin_catalog_rich() -> Dict[str, Dict[str, Any]]:
     }
 
 
+
 def _extract_plugin_version(plugin_dir: Path) -> str:
     """Extracts version string from plugin manifest, pyproject.toml, or __init__.py."""
     # 1. Try reading manifest in plugin.py

{kapsel_cli-0.5.2 → kapsel_cli-0.5.3}/kapsel/core/plugin/fetcher.py

@@ -154,3 +154,50 @@ def fetch_plugin_from_remote(
         f"from official repository (https://github.com/MrEiu/plugins)."
     )
     return False
+
+
+OFFICIAL_CATALOG_URL = "https://raw.githubusercontent.com/MrEiu/plugins/master/catalog.json"
+OFFICIAL_CATALOG_MIRROR_URL = "https://ghproxy.net/https://raw.githubusercontent.com/MrEiu/plugins/master/catalog.json"
+
+
+def fetch_remote_catalog(console: Optional[Console] = None) -> Optional[dict]:
+    """
+    Fetches the latest catalog.json from the official remote repository.
+    Tries direct GitHub raw URL first, then mirror fallback.
+    On success, writes to the local global cache and returns the parsed dict.
+    Returns None if all attempts fail (offline / unreachable).
+    """
+    import json as _json
+    from kapsel.storage.config import get_kapsel_dir
+
+    con = console or Console(legacy_windows=False)
+    headers = {"User-Agent": "Kapsel-Plugin-Fetcher/1.0"}
+
+    for url, label in [
+        (OFFICIAL_CATALOG_URL, "GitHub"),
+        (OFFICIAL_CATALOG_MIRROR_URL, "Mirror"),
+    ]:
+        try:
+            req = urllib.request.Request(url, headers=headers)
+            with urllib.request.urlopen(req, timeout=8.0) as resp:
+                if resp.status == 200:
+                    raw = resp.read().decode("utf-8")
+                    data = _json.loads(raw)
+                    if isinstance(data, dict):
+                        # Write to local cache so subsequent calls skip network
+                        global_cache = get_kapsel_dir() / "plugins_catalog.json"
+                        try:
+                            global_cache.parent.mkdir(parents=True, exist_ok=True)
+                            global_cache.write_text(
+                                _json.dumps(data, indent=2, ensure_ascii=False) + "\n",
+                                encoding="utf-8",
+                            )
+                        except Exception as cache_err:
+                            logger.debug(f"Failed to write remote catalog cache: {cache_err}")
+                        logger.debug(f"Remote catalog fetched from {label} ({len(data)} entries).")
+                        return data
+        except Exception as ex:
+            logger.debug(f"Remote catalog fetch failed from {label} ({url}): {ex}")
+
+    con.print("[dim]Could not reach remote catalog; using built-in defaults.[/]")
+    return None

{kapsel_cli-0.5.2 → kapsel_cli-0.5.3}/kapsel_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapsel-cli
-Version: 0.5.2
+Version: 0.5.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.2 → kapsel_cli-0.5.3}/kapsel_cli.egg-info/SOURCES.txt

@@ -95,6 +95,7 @@ tests/test_i18n.py
 tests/test_plugin_ai.py
 tests/test_plugin_alias.py
 tests/test_plugin_autopilot.py
+tests/test_plugin_backup.py
 tests/test_plugin_commit.py
 tests/test_plugin_fetcher.py
 tests/test_plugin_init.py

{kapsel_cli-0.5.2 → kapsel_cli-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kapsel-cli"
-version = "0.5.2"
+version = "0.5.3"
 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"

kapsel_cli-0.5.3/tests/test_plugin_backup.py

@@ -0,0 +1,161 @@
+"""
+Unit tests for Kapsel Backup Plugin.
+All comments and descriptions are in English.
+"""
+
+from io import StringIO
+from pathlib import Path
+import subprocess
+import sys
+from unittest.mock import MagicMock, patch
+import pytest
+from rich.console import Console
+
+# Ensure root directory is in sys.path
+root_dir = Path(__file__).resolve().parent.parent
+if str(root_dir) not in sys.path:
+    sys.path.insert(0, str(root_dir))
+
+from plugins.backup.plugin import BackupPlugin
+from plugins.backup.engine import (
+    resolve_bk_command,
+    format_relative_time,
+    get_backup_history,
+    select_backup_version_interactive,
+    run_bk_passthrough,
+)
+from kapsel.core.plugin.context import PluginContext
+from kapsel.core.plugin.hooks import HookType
+
+
+@pytest.fixture
+def backup_plugin():
+    plugin = BackupPlugin()
+    context = MagicMock(spec=PluginContext)
+    plugin.on_load(context)
+    return plugin
+
+
+def test_backup_manifest(backup_plugin):
+    manifest = backup_plugin.manifest
+    assert manifest.id == "backup"
+    assert manifest.name == "Backup"
+    assert manifest.version == "0.1.0"
+    assert "backup" in manifest.tags
+    assert "gitkeep" in manifest.tags
+    assert "restore" in manifest.tags
+
+
+def test_backup_on_load(backup_plugin):
+    ctx = backup_plugin.context
+    assert ctx.register_hook.call_count >= 2
+    hook_types = [call[0][0] for call in ctx.register_hook.call_args_list]
+    assert HookType.FILTER_COMMAND in hook_types
+    assert HookType.PROVIDE_COMPLETIONS in hook_types
+
+    assert ctx.register_kps_command.call_count >= 1
+    registered_names = [call[1]["name"] for call in ctx.register_kps_command.call_args_list]
+    assert "backup" in registered_names
+    assert "bk" in registered_names
+
+
+def test_filter_command(backup_plugin):
+    # Non-backup command
+    handled, cmd = backup_plugin.filter_command("git status")
+    assert not handled
+    assert cmd == "git status"
+
+    # Intercept 'bk'
+    with patch.object(backup_plugin, "handle_backup", return_value=0) as mock_handle:
+        handled, cmd = backup_plugin.filter_command("bk 'test commit'")
+        assert handled is True
+        assert cmd == ""
+        mock_handle.assert_called_once()
+        assert mock_handle.call_args[0][0] == ["'test", "commit'"]
+
+    # Intercept 'backup'
+    with patch.object(backup_plugin, "handle_backup", return_value=0) as mock_handle:
+        handled, cmd = backup_plugin.filter_command("backup")
+        assert handled is True
+        assert cmd == ""
+        mock_handle.assert_called_once()
+
+    # Intercept 'kps bk'
+    with patch.object(backup_plugin, "handle_backup", return_value=0) as mock_handle:
+        handled, cmd = backup_plugin.filter_command("kps bk log")
+        assert handled is True
+        assert cmd == ""
+        mock_handle.assert_called_once_with(["log"], pytest.approx(mock_handle.call_args[0][1]))
+
+    # Intercept 'kps backup'
+    with patch.object(backup_plugin, "handle_backup", return_value=0) as mock_handle:
+        handled, cmd = backup_plugin.filter_command("kps backup status")
+        assert handled is True
+        assert cmd == ""
+        mock_handle.assert_called_once()
+
+
+def test_provide_completions(backup_plugin):
+    ctx = MagicMock()
+    ctx.text_before_cursor = "bk res"
+
+    completions = backup_plugin.provide_completions(ctx)
+    assert any(c.text == "restore" for c in completions)
+
+    ctx.text_before_cursor = "kps backup u"
+    completions = backup_plugin.provide_completions(ctx)
+    assert any(c.text == "undo" for c in completions)
+
+    # Irrelevant command returns empty
+    ctx.text_before_cursor = "cat file"
+    assert backup_plugin.provide_completions(ctx) == []
+
+
+def test_resolve_bk_command():
+    cmd = resolve_bk_command()
+    # It should resolve either to bk.exe or node cli.js or bk in path
+    assert cmd is not None
+    assert len(cmd) >= 1
+
+
+def test_format_relative_time():
+    assert format_relative_time("invalid date") == "invalid date"
+    assert format_relative_time("2026-09-19 15:46:36 +0800") != ""
+
+
+def test_get_backup_history_mock():
+    fake_json = '{"commits": [{"hash": "1234567890", "shortHash": "1234567", "date": "2026-09-19 12:00:00 +0800", "message": "initial"}]}'
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(returncode=0, stdout=fake_json, stderr="")
+        commits, err = get_backup_history()
+        assert err is None
+        assert len(commits) == 1
+        assert commits[0]["shortHash"] == "1234567"
+
+
+def test_handle_backup_interactive_restore(backup_plugin):
+    con = Console(file=StringIO())
+    fake_commits = [
+        {"hash": "1234567890", "shortHash": "1234567", "date": "2026-09-19 12:00:00 +0800", "message": "save"}
+    ]
+
+    with patch("plugins.backup.plugin.get_backup_history", return_value=(fake_commits, None)), \
+         patch("plugins.backup.plugin.select_backup_version_interactive", return_value="1234567"), \
+         patch("plugins.backup.plugin.run_bk_passthrough", return_value=0) as mock_run:
+        ret = backup_plugin.handle_backup(["restore"], con=con)
+        assert ret == 0
+        mock_run.assert_called_once_with(["restore", "1234567"], con=con)
+
+
+def test_handle_backup_interactive_cancelled(backup_plugin):
+    con = Console(file=StringIO())
+    fake_commits = [
+        {"hash": "1234567890", "shortHash": "1234567", "date": "2026-09-19 12:00:00 +0800", "message": "save"}
+    ]
+
+    with patch("plugins.backup.plugin.get_backup_history", return_value=(fake_commits, None)), \
+         patch("plugins.backup.plugin.select_backup_version_interactive", return_value=None), \
+         patch("plugins.backup.plugin.run_bk_passthrough") as mock_run:
+        ret = backup_plugin.handle_backup(["restore"], con=con)
+        assert ret == 0
+        mock_run.assert_not_called()