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

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

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

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

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

@@ -129,10 +129,10 @@ def _install_single_plugin(
     else:
         target_name = target_raw.lower()
         dest_plugin_dir = global_plugins_dir / target_name
-        dev_plugin_dir = Path.cwd() / "plugins" / target_name
+        repo_plugin_dir = Path(__file__).resolve().parent.parent.parent.parent.parent / "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)
+        if repo_plugin_dir.exists() and repo_plugin_dir.is_dir() and (repo_plugin_dir / "__init__.py").exists():
+            shutil.copytree(repo_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

{kapsel_cli-0.7.2 → kapsel_cli-0.7.6}/kapsel/completion/kps/builtins/plugin_switch.py

@@ -121,8 +121,9 @@ def handle_enable_plugin(args: List[str], console: Optional[Console] = None) ->
     global_plugins_dir = get_kapsel_dir() / "plugins"
     dest_plugin_dir = global_plugins_dir / target
     local_dev_dir = Path.cwd() / "plugins" / target
+    repo_plugin_dir = Path(__file__).resolve().parent.parent.parent.parent.parent / "plugins" / target
 
-    if not (dest_plugin_dir.exists() or local_dev_dir.exists()):
+    if not (dest_plugin_dir.exists() or local_dev_dir.exists() or repo_plugin_dir.exists()):
         con.print(f"[dim]Plugin '[white]{target}[/]' is not installed locally. Fetching from official repository...[/]")
         from kapsel.core.plugin.fetcher import fetch_plugin_from_remote
         if not fetch_plugin_from_remote(target, dest_plugin_dir, con):

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

@@ -18,20 +18,29 @@ DEFAULT_CATALOG: Dict[str, str] = {
     "update": "Scan and update available plugin catalog and completion dictionary",
     "ai": "Terminal AI assistant and setup wizard (aichat)",
     "alias": "Cross-platform Linux command alias mapper",
+    "aria2": "Concurrent download accelerator powered by aria2c (-s 16, -x 16, -j 4)",
     "autopilot": "Production process manager and daemon supervisor (PM2)",
+    "backup": "Zero-pollution folder version backup and snapshot restore (gitkeep-cli)",
+    "commit": "Offline rule-based Conventional Commit deduction and interactive git commit manager",
+    "dispatch": "Remote execution and cluster management engine",
     "fuck": "Intelligent console command error correction (thefuck)",
     "help": "Fast interactive command cheat sheets (tealdeer)",
     "init": "Project polyglot development environment and toolchain runtime initializer (mise)",
     "install": "Unified cross-platform package manager (mpm)",
+    "kssh": "Cross-platform remote terminal connection and roaming manager",
+    "lang": "Instant terminal language, shell culture, and CLI localization switcher",
+    "mend": "Terminal environment diagnostics, doctor checks, and dependency repair",
     "portal": "Smart directory teleportation and workspace navigator (zoxide)",
+    "preview": "Smart terminal preview dispatcher (bat, glow, jq, xsv, eza, 7z/7zz, chafa) and file manager (fm)",
     "profile": "Dotfiles and workspace sync roaming (chezmoi)",
     "queue": "Background task queue and autonomous execution (Pueue)",
     "rec": "Snippet recorder and interactive runner (pet)",
     "shore": "Fast intelligent mirror source switcher (chsrc)",
+    "template": "Project boilerplate initialization and code templating engine",
+    "trans": "Command output translator powered by fanyi and translate-shell",
 }
 
 
-
 def _resolve_catalog_paths():
     """Returns candidate paths for catalog.json in order of priority."""
     paths = []
@@ -53,12 +62,20 @@ def _resolve_catalog_paths():
     if workspace_catalog not in paths:
         paths.append(workspace_catalog)
 
-    # 3. Global runtime plugins directory
+    # 3. Kapsel repository root plugins/catalog.json (independent of CWD)
+    try:
+        repo_catalog = Path(__file__).resolve().parent.parent.parent.parent / "plugins" / "catalog.json"
+        if repo_catalog.is_file() and repo_catalog not in paths:
+            paths.append(repo_catalog)
+    except Exception:
+        pass
+
+    # 4. Global runtime plugins directory (~/.kapsel/plugins/catalog.json)
     global_in_plugins = get_kapsel_dir() / "plugins" / "catalog.json"
     if global_in_plugins not in paths:
         paths.append(global_in_plugins)
 
-    # 4. Global root catalog fallback
+    # 5. Global root catalog fallback (~/.kapsel/catalog.json)
     global_root = get_kapsel_dir() / "catalog.json"
     if global_root not in paths:
         paths.append(global_root)
@@ -111,40 +128,10 @@ def load_plugin_catalog_rich() -> Dict[str, Dict[str, Any]]:
             except Exception:
                 pass
 
-    # 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)
+    # Purely local fallback: built-in DEFAULT_CATALOG (0ms, zero network requests)
     return {
         k: {
-            "version": "0.2.0" if k in ("alias", "install") else "0.1.0",
+            "version": "0.1.0",
             "description": v,
             "changelog": "",
         }

{kapsel_cli-0.7.2 → kapsel_cli-0.7.6}/kapsel/core/plugin/fetcher.py

@@ -25,23 +25,44 @@ OFFICIAL_ARCHIVE_URL = "https://github.com/MrEiu/plugins/archive/refs/heads/mast
 OFFICIAL_ARCHIVE_MIRROR_URL = "https://ghproxy.net/https://github.com/MrEiu/plugins/archive/refs/heads/master.tar.gz"
 
 
+def is_github_reachable(timeout: float = 1.0) -> bool:
+    """
+    Quickly tests connectivity to GitHub with a strict timeout of at most 1 second.
+    If unreachable or timeout expires, returns False so caller immediately falls back to mirror.
+    """
+    try:
+        req = urllib.request.Request("https://github.com", headers={"User-Agent": "Kapsel-Probe/1.0"})
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return resp.status in (200, 301, 302)
+    except Exception:
+        return False
+
+
 def _fetch_via_git(plugin_name: str, dest_dir: Path, console: Console) -> bool:
     """Attempts to fetch a plugin using git shallow clone."""
     if not shutil.which("git"):
         return False
 
+    # Probe GitHub connectivity with 1s limit; if unreachable, immediately switch to mirror
+    use_mirror = not is_github_reachable(timeout=1.0)
+    repo_urls = (
+        [(OFFICIAL_PLUGINS_REPO_MIRROR_GIT, "Mirror (ghproxy)"), (OFFICIAL_PLUGINS_REPO_GIT, "GitHub")]
+        if use_mirror
+        else [(OFFICIAL_PLUGINS_REPO_GIT, "GitHub"), (OFFICIAL_PLUGINS_REPO_MIRROR_GIT, "Mirror (ghproxy)")]
+    )
+
     with tempfile.TemporaryDirectory(prefix="kapsel_plugin_git_") as tmp_str:
         tmp_path = Path(tmp_str)
-        console.print(f"[dim]Attempting Git clone from {OFFICIAL_PLUGINS_REPO_GIT}...[/]")
 
         cloned = False
-        for repo_url in [OFFICIAL_PLUGINS_REPO_GIT, OFFICIAL_PLUGINS_REPO_MIRROR_GIT]:
+        for repo_url, label in repo_urls:
             try:
+                console.print(f"[dim]Attempting Git clone via {label}...[/]")
                 res = subprocess.run(
                     ["git", "clone", "--depth", "1", repo_url, str(tmp_path / "repo")],
                     capture_output=True,
                     text=True,
-                    timeout=20.0,
+                    timeout=15.0,
                 )
                 if res.returncode == 0:
                     cloned = True
@@ -65,14 +86,22 @@ def _fetch_via_archive(plugin_name: str, dest_dir: Path, console: Console) -> bo
     """Attempts to fetch a plugin by streaming and extracting the GitHub tarball."""
     console.print(f"[dim]Downloading plugin package from remote repository...[/]")
 
+    # Probe GitHub connectivity with 1s limit; if unreachable, immediately switch to mirror
+    use_mirror = not is_github_reachable(timeout=1.0)
+    candidates = (
+        [(OFFICIAL_ARCHIVE_MIRROR_URL, "Mirror (ghproxy)"), (OFFICIAL_ARCHIVE_URL, "GitHub")]
+        if use_mirror
+        else [(OFFICIAL_ARCHIVE_URL, "GitHub"), (OFFICIAL_ARCHIVE_MIRROR_URL, "Mirror (ghproxy)")]
+    )
+
     headers = {"User-Agent": "Kapsel-Plugin-Fetcher/1.0"}
     archive_bytes: Optional[bytes] = None
 
-    for url, label in [(OFFICIAL_ARCHIVE_URL, "GitHub"), (OFFICIAL_ARCHIVE_MIRROR_URL, "Mirror")]:
+    for url, label in candidates:
         try:
             console.print(f"[dim]Connecting to {label}...[/]")
             req = urllib.request.Request(url, headers=headers)
-            with urllib.request.urlopen(req, timeout=15.0) as resp:
+            with urllib.request.urlopen(req, timeout=10.0) as resp:
                 if resp.status == 200:
                     archive_bytes = resp.read()
                     break
@@ -173,25 +202,32 @@ def fetch_remote_catalog(console: Optional[Console] = None) -> Optional[dict]:
     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"),
-    ]:
+    use_mirror = not is_github_reachable(timeout=1.0)
+    candidates = (
+        [(OFFICIAL_CATALOG_MIRROR_URL, "Mirror (ghproxy)"), (OFFICIAL_CATALOG_URL, "GitHub")]
+        if use_mirror
+        else [(OFFICIAL_CATALOG_URL, "GitHub"), (OFFICIAL_CATALOG_MIRROR_URL, "Mirror (ghproxy)")]
+    )
+
+    for url, label in candidates:
         try:
             req = urllib.request.Request(url, headers=headers)
-            with urllib.request.urlopen(req, timeout=8.0) as resp:
+            with urllib.request.urlopen(req, timeout=5.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"
+                        # Write to global plugins catalog directory matching _resolve_catalog_paths
+                        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",
                             )
+                            # Remove obsolete plugins_catalog.json if present
+                            legacy_cache = get_kapsel_dir() / "plugins_catalog.json"
+                            legacy_cache.unlink(missing_ok=True)
                         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).")

{kapsel_cli-0.7.2 → kapsel_cli-0.7.6}/kapsel/core/tools/installer.py

@@ -48,52 +48,105 @@ def get_current_platform_keys() -> List[str]:
     return keys
 
 
+def get_tool_bin_candidates(tool_def: Optional[Dict[str, Any]], fallback_name: str = "tool") -> List[str]:
+    """
+    Extracts binary candidate names for the current platform from tool definition.
+    Supports string bin, dictionary bin per platform (e.g. windows: 7z, unix: 7zz),
+    platforms.<os>.bin, and common known aliases (e.g. 7z <-> 7zz).
+    Returns a prioritized list of binary name candidates.
+    """
+    if not tool_def:
+        return [fallback_name]
+
+    candidates: List[str] = []
+    plat_keys = get_current_platform_keys()
+
+    # 1. Platform-specific bin in platforms section (e.g. platforms.unix.bin or platforms.windows.bin)
+    platforms_def = tool_def.get("platforms", {})
+    if isinstance(platforms_def, dict):
+        for key in reversed(plat_keys):
+            p_data = platforms_def.get(key)
+            if isinstance(p_data, dict) and "bin" in p_data:
+                b = p_data["bin"]
+                if isinstance(b, str) and b and b not in candidates:
+                    candidates.append(b)
+
+    # 2. Tool-level 'bin' attribute (dict or str)
+    raw_bin = tool_def.get("bin")
+    if isinstance(raw_bin, dict):
+        for key in reversed(plat_keys):
+            if key in raw_bin:
+                b = raw_bin[key]
+                if isinstance(b, str) and b and b not in candidates:
+                    candidates.append(b)
+    elif isinstance(raw_bin, str) and raw_bin:
+        if raw_bin not in candidates:
+            candidates.append(raw_bin)
+
+    # 3. Tool name fallback
+    t_name = tool_def.get("name")
+    if isinstance(t_name, str) and t_name and t_name not in candidates:
+        candidates.append(t_name)
+
+    if not candidates:
+        candidates.append(fallback_name)
+
+    # 4. Canonical tool aliases (e.g. 7z <-> 7zz)
+    if "7z" in candidates and "7zz" not in candidates:
+        candidates.append("7zz")
+    elif "7zz" in candidates and "7z" not in candidates:
+        candidates.append("7z")
+
+    return candidates
+
+
 def resolve_tool_executable(tool_name: str, bin_dir: Optional[Path] = None) -> Optional[str]:
     """
     Resolves the executable path of a tool if installed in PATH,
     Kapsel bin, Scoop shims, WinGet links, or Cargo bin.
     """
     tool_def = get_tool(tool_name)
-    bin_name = tool_def.get("bin", tool_name) if tool_def else tool_name
-
-    # 1. Standard PATH
-    found = shutil.which(bin_name)
-    if found:
-        return found
-
-    is_win = sys.platform == "win32"
-    exe_name = f"{bin_name}.exe" if is_win else bin_name
+    bin_candidates = get_tool_bin_candidates(tool_def, fallback_name=tool_name)
     b_dir = bin_dir or get_kapsel_bin_dir()
+    is_win = sys.platform == "win32"
 
-    # 2. Local Kapsel bin directory
-    local_target = b_dir / exe_name
-    if local_target.exists():
-        return str(local_target)
+    for bin_name in bin_candidates:
+        # 1. Standard PATH
+        found = shutil.which(bin_name)
+        if found:
+            return found
 
-    # 3. Windows-specific typical locations
-    if is_win:
-        user_home = Path(os.environ.get("USERPROFILE", Path.home()))
-        candidates = [
-            user_home / "scoop" / "shims" / exe_name,
-            user_home / "scoop" / "apps" / bin_name / "current" / exe_name,
-            user_home / "AppData" / "Local" / "Microsoft" / "WinGet" / "Links" / exe_name,
-            user_home / ".cargo" / "bin" / exe_name,
-        ]
-        for cand in candidates:
-            if cand.is_file():
-                return str(cand)
-    else:
-        # 4. Unix-specific typical locations
-        user_home = Path(os.environ.get("HOME", Path.home()))
-        candidates = [
-            Path("/opt/homebrew/bin") / exe_name,
-            Path("/usr/local/bin") / exe_name,
-            Path("/usr/bin") / exe_name,
-            user_home / ".cargo" / "bin" / exe_name,
-        ]
-        for cand in candidates:
-            if cand.is_file():
-                return str(cand)
+        exe_name = f"{bin_name}.exe" if is_win else bin_name
+
+        # 2. Local Kapsel bin directory
+        local_target = b_dir / exe_name
+        if local_target.exists():
+            return str(local_target)
+
+        # 3. Windows-specific typical locations
+        if is_win:
+            user_home = Path(os.environ.get("USERPROFILE", Path.home()))
+            candidates = [
+                user_home / "scoop" / "shims" / exe_name,
+                user_home / "scoop" / "apps" / bin_name / "current" / exe_name,
+                user_home / "AppData" / "Local" / "Microsoft" / "WinGet" / "Links" / exe_name,
+                user_home / ".cargo" / "bin" / exe_name,
+            ]
+            for cand in candidates:
+                if cand.is_file():
+                    return str(cand)
+        else:
+            # 4. Unix-specific typical locations
+            user_home = Path(os.environ.get("HOME", Path.home()))
+            candidates = [
+                Path("/opt/homebrew/bin") / exe_name,
+                Path("/usr/local/bin") / exe_name,
+                Path("/usr/bin") / exe_name,
+                user_home / ".cargo" / "bin" / exe_name,
+            ]
+            for cand in candidates:
+                if cand.is_file():
+                    return str(cand)
 
     return None
 
@@ -220,8 +273,8 @@ class ToolInstaller:
             return False
 
         dest = strategy.get("dest")
-        is_win = sys.platform == "win32"
-        bin_name = tool_def.get("bin", tool_def.get("name", "tool"))
+        bin_candidates = get_tool_bin_candidates(tool_def, fallback_name=tool_def.get("name", "tool"))
+        bin_name = bin_candidates[0]
         exe_name = f"{bin_name}.exe" if is_win else bin_name
 
         target_file = self.bin_dir / exe_name

{kapsel_cli-0.7.2 → kapsel_cli-0.7.6}/kapsel/core/tools/registry.py

@@ -146,9 +146,28 @@ class ToolRegistry:
             return all_tools[tool_name]
 
         for _, tool_def in all_tools.items():
-            if tool_def.get("bin") == tool_name or tool_def.get("name") == tool_name:
+            b = tool_def.get("bin")
+            if isinstance(b, dict):
+                if tool_name in b.values():
+                    return tool_def
+            elif b == tool_name:
                 return tool_def
 
+            if tool_def.get("name") == tool_name:
+                return tool_def
+
+            platforms = tool_def.get("platforms", {})
+            if isinstance(platforms, dict):
+                for _, p_data in platforms.items():
+                    if isinstance(p_data, dict) and p_data.get("bin") == tool_name:
+                        return tool_def
+
+        # Canonical aliases (e.g. 7zz <-> 7z)
+        if tool_name == "7zz" and "7z" in all_tools:
+            return all_tools["7z"]
+        if tool_name == "7z" and "7zz" in all_tools:
+            return all_tools["7zz"]
+
         return None
 
     def sync_aggregated_file(self, target_path: Optional[Path] = None) -> Path:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kapsel-cli
-Version: 0.7.2
+Version: 0.7.6
 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.7.2 → kapsel_cli-0.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kapsel-cli"
-version = "0.7.2"
+version = "0.7.6"
 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.7.2 → kapsel_cli-0.7.6}/tests/test_plugin_install.py

@@ -185,7 +185,7 @@ def test_handle_install_subcommands(tmp_path):
             ret = plugin.handle_install(["--help"], con)
             assert ret == 0
             out = con.export_text()
-            assert "kps install <package_name>" in out
+            assert "kps install <package_name" in out
 
 
 def test_handle_install_forwarding():
@@ -198,7 +198,7 @@ def test_handle_install_forwarding():
             mock_run.return_value = 0
             ret = plugin.handle_install(["curl"], con)
             assert ret == 0
-            mock_run.assert_called_once_with("install", ["--winget", "--scoop", "curl"], con)
+            mock_run.assert_called_once_with("install", ["--winget", "--scoop", "curl"], con, custom_paths={})
 
 
 def test_search_item_weights_and_sorting():
@@ -289,3 +289,28 @@ def test_build_results_table_top_3_grouping():
     # Verify table columns exist and rows represent scoop and top-3 winget plus expand row
     assert len(table.rows) == 1 + 3 + 1  # 1 scoop + 3 winget + 1 expandable row
 
+
+def test_order_subcommand_interactive_dispatch(tmp_path):
+    """Verify 'kps install order' dispatches to run_order_interactive when isatty is True."""
+    plugin = InstallPlugin()
+    mock_context = MagicMock()
+    mock_context.plugin_data_dir = tmp_path
+    plugin.context = mock_context
+    con = Console(record=True)
+
+    with patch("sys.stdin.isatty", return_value=True):
+        with patch("plugins.install.order_ui.run_order_interactive", return_value=0) as mock_ui:
+            ret = plugin.handle_install(["order"], con)
+            assert ret == 0
+            mock_ui.assert_called_once_with(plugin, con)
+
+
+def test_order_ui_info_resolution():
+    """Verify _get_manager_info returns executable status."""
+    from plugins.install.order_ui import _get_manager_info
+    # Test custom path
+    info, present = _get_manager_info("custom_m", {"custom_m": str(Path(__file__))})
+    assert present is True
+    assert "test_plugin_install.py" in info
+
+