codeboarding 0.15.2__tar.gz → 0.15.3__tar.gz

{codeboarding-0.15.2/codeboarding.egg-info → codeboarding-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.15.2
+Version: 0.15.3
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT
@@ -112,7 +112,7 @@ pip install codeboarding --extra-index-url https://pip.codeboarding.org/simple/
 
 > Installing into the global Python environment with `pip` is not recommended — it can cause dependency conflicts and will fail if the system Python is not 3.12 or 3.13.
 
-Language server binaries are downloaded automatically on first use. To pre-install them explicitly (useful in CI or restricted environments):
+Each analysis downloads the language servers its repository's languages need, on first use. To pre-install all of them (useful in CI or restricted environments):
 
 ```bash
 codeboarding-setup

{codeboarding-0.15.2 → codeboarding-0.15.3}/PYPI.md

@@ -38,7 +38,7 @@ pip install codeboarding --extra-index-url https://pip.codeboarding.org/simple/
 
 > Installing into the global Python environment with `pip` is not recommended — it can cause dependency conflicts and will fail if the system Python is not 3.12 or 3.13.
 
-Language server binaries are downloaded automatically on first use. To pre-install them explicitly (useful in CI or restricted environments):
+Each analysis downloads the language servers its repository's languages need, on first use. To pre-install all of them (useful in CI or restricted environments):
 
 ```bash
 codeboarding-setup

{codeboarding-0.15.2 → codeboarding-0.15.3}/README.md

@@ -153,7 +153,7 @@ codeboarding-render /path/to/analysis.json --format mdx --output-dir /path/to/do
 python codeboarding_cli/render.py ../../demo/markitdown/.codeboarding/analysis.json --format md
 ```
 
-`python -m infra.install` and `codeboarding-setup` download language server binaries to `~/.codeboarding/servers/`, shared across projects. Node.js (and its bundled `npm`) is required for the Python, TypeScript, JavaScript, and PHP language servers; if neither `node` nor `CODEBOARDING_NODE_PATH` is set, setup downloads a pinned Node.js runtime into `~/.codeboarding/servers/nodeenv/` automatically.
+An analysis downloads the language servers its repository's languages need into `~/.codeboarding/servers/` the first time it needs them, shared across projects; `python -m infra.install` and `codeboarding-setup` download all of them up front. Node.js (and its bundled `npm`) is required for the Python, TypeScript, JavaScript, and PHP language servers; if neither `node` nor `CODEBOARDING_NODE_PATH` is set, setup downloads a pinned Node.js runtime into `~/.codeboarding/servers/nodeenv/` automatically.
 
 ## Configuration
 
@@ -172,6 +172,7 @@ On first run, CodeBoarding creates `~/.codeboarding/config.toml`. Set one provid
 # openrouter_api_key        = "sk-..."
 # orcarouter_api_key        = "sk-orca-..."   # model routing gateway (https://www.orcarouter.ai)
 # requesty_api_key          = "rqsty-..."     # LLM gateway (https://www.requesty.ai)
+# opper_api_key             = "..."           # EU-hosted AI gateway (https://opper.ai)
 # litellm_base_url          = "http://localhost:4000"  # LiteLLM proxy server URL (required)
 # litellm_api_key           = "sk-..."           # LiteLLM proxy server key (optional)
 
@@ -249,7 +250,7 @@ for the actual depth. Existing baseline loading behavior is unchanged: prefer
 - Languages: Python, TypeScript, JavaScript, Java, Kotlin, Go, PHP, Rust, C#.
   - Java needs a JDK (21 recommended).
   - Kotlin is analysed with JetBrains' [kotlin-lsp](https://github.com/Kotlin/kotlin-lsp) (about 360 MB with its own Java runtime, under the [JetBrains Free Plugin License](https://github.com/Kotlin/kotlin-lsp/blob/main/kotlin-vscode/LICENSE.txt)) and needs glibc 2.34 or newer on Linux. Kotlin calls into Java are not drawn yet.
-- LLM providers: OpenAI, Anthropic, Google, Vercel AI Gateway, AWS Bedrock, Ollama, OpenRouter, OrcaRouter, Requesty, LiteLLM proxy, and more.
+- LLM providers: OpenAI, Anthropic, Google, Vercel AI Gateway, AWS Bedrock, Ollama, OpenRouter, OrcaRouter, Requesty, Opper, LiteLLM proxy, and more.
 
 ## Examples
 

{codeboarding-0.15.2 → codeboarding-0.15.3}/agents/llm_config.py

@@ -302,6 +302,19 @@ LLM_PROVIDERS = {
             "max_retries": 0,
         },
     ),
+    "opper": LLMConfig(
+        chat_class=ChatOpenAI,
+        selection_envs=["OPPER_API_KEY"],
+        api_key_env="OPPER_API_KEY",
+        agent_model="gemini-3.8-flash",
+        base_url_env="OPPER_BASE_URL",
+        default_base_url="https://api.opper.ai/v3/compat",
+        extra_args={
+            "max_tokens": None,
+            "timeout": LLMDefaults.REQUEST_TIMEOUT_SECONDS,
+            "max_retries": 0,
+        },
+    ),
     "litellm": LLMConfig(
         chat_class=ChatOpenAI,
         # Base URL only: a key alone must not select litellm, since there is no

{codeboarding-0.15.2 → codeboarding-0.15.3/codeboarding.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.15.2
+Version: 0.15.3
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT
@@ -112,7 +112,7 @@ pip install codeboarding --extra-index-url https://pip.codeboarding.org/simple/
 
 > Installing into the global Python environment with `pip` is not recommended — it can cause dependency conflicts and will fail if the system Python is not 3.12 or 3.13.
 
-Language server binaries are downloaded automatically on first use. To pre-install them explicitly (useful in CI or restricted environments):
+Each analysis downloads the language servers its repository's languages need, on first use. To pre-install all of them (useful in CI or restricted environments):
 
 ```bash
 codeboarding-setup

{codeboarding-0.15.2 → codeboarding-0.15.3}/codeboarding.egg-info/SOURCES.txt

@@ -187,6 +187,7 @@ static_analyzer/lsp_client/__init__.py
 static_analyzer/lsp_client/diagnostics.py
 static_analyzer/typescript_plugin/node_modules/codeboarding-workspace-sources/index.js
 static_analyzer/typescript_plugin/node_modules/codeboarding-workspace-sources/package.json
+tests/test_devcontainer.py
 tests/test_persisted_analysis_artifacts.py
 tests/test_pyproject_packages.py
 tests/test_view_instructions.py

{codeboarding-0.15.2 → codeboarding-0.15.3}/codeboarding_cli/bootstrap.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from agents.llm_config import configure_models, validate_api_key_provided
 from health.plugins import get_registries, load_plugins
 from diagram_analysis.run_context import RunPaths
-from infra.install import ensure_tools
+from infra.install import enable_on_demand_install, ensure_tools
 from infra.logging_config import setup_logging
 from infra.user_config import ensure_config_template, load_user_config
 from infra.utils import CODEBOARDING_DIR_NAME
@@ -41,4 +41,6 @@ def bootstrap_environment(output_dir: Path, binary_location: Path | None) -> Non
         # repairs a deleted ~/.codeboarding/servers/nodeenv/ independently of the
         # fingerprint check. Pre-gating with needs_install() here would skip that
         # repair when binaries look current but the runtime directory was deleted.
-        ensure_tools(auto_install_npm=True, auto_install_vcpp=True)
+        # Only the base tools here: the analysis installs its languages' servers once it has found them.
+        ensure_tools(auto_install_npm=True, auto_install_vcpp=True, languages=())
+        enable_on_demand_install(auto_install_npm=True, auto_install_vcpp=True)

{codeboarding-0.15.2 → codeboarding-0.15.3}/infra/install.py

@@ -1,21 +1,24 @@
 import argparse
 import io
+import logging
 import os
 import platform
 import shutil
 import subprocess
 import sys
 import tarfile
-from collections.abc import Callable
+from collections.abc import Callable, Collection
 from dataclasses import dataclass
 from enum import StrEnum
 from pathlib import Path
 
 import requests
 from infra.tool_registry import (
+    ALL_LANGUAGE_KEYS,
     PINNED_NODE_VERSION,
     TOOL_REGISTRY,
     ProgressCallback,
+    ToolDependency,
     ToolKind,
     acquire_lock,
     archive_launcher_path,
@@ -32,6 +35,7 @@ from infra.tool_registry import (
     platform_bin_dir,
     preferred_node_path,
     preferred_npm_command,
+    required_tools,
     write_manifest,
 )
 from infra.tool_registry.java import find_java_21_or_later
@@ -39,6 +43,8 @@ from infra.tool_registry.registry import ConfigSection, PackageManagerToolSource
 from infra.vscode_constants import VSCODE_CONFIG
 from infra.user_config import ensure_config_template
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True, slots=True)
 class LanguageSupportCheck:
@@ -294,25 +300,26 @@ def get_platform_bin_dir(servers_dir: Path) -> Path:
     return platform_bin_dir(servers_dir)
 
 
-def install_node_servers(target_dir: Path, on_progress: ProgressCallback | None = None):
-    """Install Node.js based servers (TypeScript, Pyright) using npm in target_dir."""
+def install_node_servers(
+    target_dir: Path, on_progress: ProgressCallback | None = None, deps: Collection[ToolDependency] = TOOL_REGISTRY
+):
+    """Install the selected Node.js servers using npm; defaults to every registered Node.js server."""
     print("Step: Node.js servers installation started")
     target_dir.mkdir(parents=True, exist_ok=True)
 
-    node_deps = [d for d in TOOL_REGISTRY if d.kind is ToolKind.NODE]
+    node_deps = [d for d in deps if d.kind is ToolKind.NODE]
     install_node_tools(target_dir, node_deps, on_progress=on_progress)
 
     # Verify the installation
-    ts_lsp_path = target_dir / "node_modules" / ".bin" / "typescript-language-server"
-    py_lsp_path = target_dir / "node_modules" / ".bin" / "pyright-langserver"
-    php_lsp_path = target_dir / "node_modules" / ".bin" / "intelephense"
+    names = {
+        "typescript": "TypeScript Language Server",
+        "python": "Pyright Language Server",
+        "php": "Intelephense",
+    }
 
     success = True
-    for name, path in [
-        ("TypeScript Language Server", ts_lsp_path),
-        ("Pyright Language Server", py_lsp_path),
-        ("Intelephense", php_lsp_path),
-    ]:
+    for dep in node_deps:
+        name, path = names.get(dep.key, dep.binary_name), target_dir / "node_modules" / ".bin" / dep.binary_name
         if path.exists():
             print(f"Step: {name} installation finished: success")
         else:
@@ -456,10 +463,15 @@ def resolve_missing_vcpp(auto_install_vcpp: bool = False) -> bool:
     return False
 
 
-def download_binaries(target_dir: Path, auto_install_vcpp: bool = False, on_progress: ProgressCallback | None = None):
-    """Download tokei and gopls binaries from the latest GitHub release."""
+def download_binaries(
+    target_dir: Path,
+    auto_install_vcpp: bool = False,
+    on_progress: ProgressCallback | None = None,
+    deps: Collection[ToolDependency] = TOOL_REGISTRY,
+):
+    """Download the selected native binaries; defaults to every registered native tool."""
     print("Step: Binary download started")
-    native_deps = [d for d in TOOL_REGISTRY if d.kind is ToolKind.NATIVE]
+    native_deps = [d for d in deps if d.kind is ToolKind.NATIVE]
     install_native_tools(target_dir, native_deps, on_progress=on_progress)
 
     # Verify downloaded binaries actually work (catch missing DLL issues on Windows)
@@ -498,10 +510,12 @@ def download_binaries(target_dir: Path, auto_install_vcpp: bool = False, on_prog
     print("Step: Binary download finished")
 
 
-def download_jdtls(target_dir: Path, on_progress: ProgressCallback | None = None):
-    """Download and extract the archive tools: JDTLS and kotlin-lsp."""
+def download_jdtls(
+    target_dir: Path, on_progress: ProgressCallback | None = None, deps: Collection[ToolDependency] = TOOL_REGISTRY
+):
+    """Download the selected archive tools; defaults to every registered archive tool."""
     print("Step: JDTLS download started")
-    archive_deps = [d for d in TOOL_REGISTRY if d.kind is ToolKind.ARCHIVE]
+    archive_deps = [d for d in deps if d.kind is ToolKind.ARCHIVE]
     for dep in archive_deps:
         install_archive_tool(target_dir, dep, on_progress=on_progress)
 
@@ -509,13 +523,15 @@ def download_jdtls(target_dir: Path, on_progress: ProgressCallback | None = None
     return True
 
 
-def install_package_manager_lsp_servers(target_dir: Path, on_progress: ProgressCallback | None = None) -> None:
-    """Install LSP servers distributed via user-provided package managers.
+def install_package_manager_lsp_servers(
+    target_dir: Path, on_progress: ProgressCallback | None = None, deps: Collection[ToolDependency] = TOOL_REGISTRY
+) -> None:
+    """Install the selected package-manager servers; defaults to every registered package-manager server.
 
     Skips cleanly when the package manager itself is absent — the adapter raises a meaningful error
     at analysis time.
     """
-    pm_deps = [d for d in TOOL_REGISTRY if d.kind is ToolKind.PACKAGE_MANAGER]
+    pm_deps = [d for d in deps if d.kind is ToolKind.PACKAGE_MANAGER]
     if not pm_deps:
         return
     print("Step: Package-manager tool installation started")
@@ -588,101 +604,6 @@ def install_pre_commit_hooks():
         pass
 
 
-def _language_checks_from_registry(target_dir: Path) -> list[LanguageSupportCheck]:
-    """Build one LanguageSupportCheck per LSP language listed in VSCODE_CONFIG.
-
-    Data-driven so adding a language to TOOL_REGISTRY + VSCODE_CONFIG
-    automatically flows to the setup summary — no second list to keep in sync.
-    Each tool dep can surface multiple display languages (e.g. the
-    ``typescript`` entry covers both TypeScript and JavaScript).
-    """
-    target_dir = target_dir.resolve()
-    # native/package-manager installers already warn-and-skip on unsupported
-    # hosts; the summary should mirror that instead of crashing when the host has
-    # no ``platform_bin_dir`` layout.
-    try:
-        platform_bin_dir: Path | None = get_platform_bin_dir(target_dir)
-    except RuntimeError:
-        platform_bin_dir = None
-    is_win = platform.system() == "Windows"
-    node_ext = ".cmd" if is_win else ""
-    native_ext = ".exe" if is_win else ""
-    npm_missing = "npm not available"
-
-    checks: list[LanguageSupportCheck] = []
-    lsp_servers = VSCODE_CONFIG.get("lsp_servers", {})
-
-    for dep in TOOL_REGISTRY:
-        if dep.config_section != ConfigSection.LSP_SERVERS:
-            continue
-        config_entry = lsp_servers.get(dep.key)
-        if config_entry is None:
-            continue
-        languages: list[str] = list(config_entry.get("languages", []) or [dep.key])
-
-        paths: list[Path] = []
-        fallback_available = False
-        requires_npm = False
-        reason_requirement = f"{dep.binary_name} not installed"
-        reason_binary = f"{dep.binary_name} binary not found"
-
-        if dep.kind is ToolKind.NATIVE:
-            if platform_bin_dir is not None:
-                paths.append(platform_bin_dir / f"{dep.binary_name}{native_ext}")
-            else:
-                reason_requirement = f"{dep.binary_name} unavailable on this platform"
-                reason_binary = reason_requirement
-        elif dep.kind is ToolKind.NODE:
-            requires_npm = True
-            reason_requirement = npm_missing
-            paths.append(target_dir / "node_modules" / ".bin" / f"{dep.binary_name}{node_ext}")
-            # Python pyright also resolves from the active environment.
-            if dep.key == "python":
-                env_path = shutil.which("pyright-langserver") or shutil.which("pyright-python-langserver")
-                fallback_available = bool(env_path)
-                reason_requirement = "pyright-langserver not found in node_modules or active environment"
-                reason_binary = reason_requirement
-        elif dep.kind is ToolKind.ARCHIVE:
-            # An archive is validated by its launcher, or for JDTLS by directory
-            # presence (+ plugins/ subdir), mirroring has_required_tools.
-            subdir = dep.archive_subdir or dep.key
-            paths.append(archive_launcher_path(target_dir, dep) or target_dir / "bin" / subdir)
-            reason_requirement = f"{subdir} installation not found"
-            reason_binary = reason_requirement
-            # Java analysis can still proceed when a system Java 21+ is available
-            # (jdtls's bundled JRE is the default, but not strictly required).
-            if dep.key == "java":
-                fallback_available = bool(find_java_21_or_later())
-                reason_binary = "jdtls or Java 21+ not found"
-        elif dep.kind is ToolKind.PACKAGE_MANAGER:
-            pm_path = package_manager_tool_path(target_dir, dep)
-            if pm_path is not None:
-                paths.append(pm_path)
-            manager = (
-                dep.source.manager_binary if isinstance(dep.source, PackageManagerToolSource) else "package manager"
-            )
-            if pm_path is None:
-                reason_requirement = f"{dep.binary_name} unavailable on this platform"
-            else:
-                reason_requirement = f"{dep.binary_name} not installed ({manager} unavailable or install failed)"
-            reason_binary = reason_requirement
-
-        health_check = check_rust_toolchain if dep.key == "rust" else None
-        for lang in languages:
-            checks.append(
-                LanguageSupportCheck(
-                    language=lang,
-                    paths=list(paths),
-                    requires_npm=requires_npm,
-                    fallback_available=fallback_available,
-                    reason_if_requirement_missing=reason_requirement,
-                    reason_if_binary_missing=reason_binary,
-                    health_check=health_check,
-                )
-            )
-    return checks
-
-
 def print_language_support_summary(npm_available: bool, target_dir: Path):
     """Print which language analyses are currently available based on installed tools."""
     print("Step: Language support summary")
@@ -697,9 +618,12 @@ def ensure_tools(
     auto_install_npm: bool = False,
     auto_install_vcpp: bool = False,
     on_progress: ProgressCallback | None = None,
+    languages: Collection[str] = ALL_LANGUAGE_KEYS,
 ) -> None:
     """Install tools to ~/.codeboarding/servers/ if needed. No-op if already current.
 
+    *languages* are ``lsp_servers`` keys. Defaults to all languages; an empty collection installs only base tools.
+
     Uses a file lock so that concurrent instances (multiple VSCode windows)
     don't corrupt binaries by downloading simultaneously.
 
@@ -709,24 +633,48 @@ def ensure_tools(
     servers_dir = get_servers_dir()
     servers_dir.mkdir(parents=True, exist_ok=True)
     lock_path = servers_dir / ".download.lock"
+    deps = required_tools(languages)
 
     with open(lock_path, "w") as lock_fd:
         acquire_lock(lock_fd)
-
-        # Run above needs_install() so a deleted nodeenv/ is always repaired
-        # (fingerprints alone wouldn't detect it).
-        ensure_node_runtime(target_dir=servers_dir, auto_install_npm=auto_install_npm)
-
-        if not needs_install():
+        if any(dep.kind is ToolKind.NODE for dep in deps):
+            # Run above needs_install() so a deleted nodeenv/ is always repaired
+            # (fingerprints alone wouldn't detect it).
+            ensure_node_runtime(target_dir=servers_dir, auto_install_npm=auto_install_npm)
+        if not needs_install(languages):
             return
-
         run_install(
             target_dir=servers_dir,
             auto_install_npm=auto_install_npm,
             auto_install_vcpp=auto_install_vcpp,
             on_progress=on_progress,
+            deps=deps,
         )
-        write_manifest()
+        write_manifest(deps)
+
+
+_on_demand_install: dict[str, bool] = {}
+
+
+def enable_on_demand_install(auto_install_npm: bool = False, auto_install_vcpp: bool = False) -> None:
+    """Let each analysis install the language servers its repository needs once it has found its languages.
+
+    Why: a run with ``--binary-location`` brings its own servers, so installing stays off unless the
+    entry point turns it on.
+    """
+    _on_demand_install.update(auto_install_npm=auto_install_npm, auto_install_vcpp=auto_install_vcpp)
+
+
+def ensure_language_servers(languages: Collection[str]) -> None:
+    """Install the servers of *languages* (``lsp_servers`` keys) when on-demand installs are enabled."""
+    if not _on_demand_install:
+        return
+    logger.info("Language servers needed: %s", ", ".join(sorted(languages)) or "none")
+    ensure_tools(
+        auto_install_npm=_on_demand_install["auto_install_npm"],
+        auto_install_vcpp=_on_demand_install["auto_install_vcpp"],
+        languages=languages,
+    )
 
 
 def run_install(
@@ -734,30 +682,34 @@ def run_install(
     auto_install_npm: bool = False,
     auto_install_vcpp: bool = False,
     on_progress: ProgressCallback | None = None,
+    deps: Collection[ToolDependency] = TOOL_REGISTRY,
 ) -> None:
     """Core installation logic — callable programmatically or via CLI.
 
-    Downloads language server binaries to target_dir (defaults to ~/.codeboarding/servers/).
-    Safe to call multiple times; already-installed tools are skipped.
+    Downloads the selected tools (every registered tool by default) to
+    target_dir (defaults to ~/.codeboarding/servers/). Safe to call multiple times;
+    already-installed tools are skipped.
 
     The ``on_progress`` callback receives ``(tool_name, step, total)`` where
     step/total count across *all* tool categories (native, node, archive).
     """
     target = (target_dir or get_servers_dir()).resolve()
     target.mkdir(parents=True, exist_ok=True)
+    selected = list(deps)
 
     ensure_config_template()
 
-    # Covers the codeboarding-setup -> run_install path, which bypasses ensure_tools().
-    ensure_node_runtime(target_dir=target, auto_install_npm=auto_install_npm)
+    node_deps = [d for d in selected if d.kind is ToolKind.NODE]
+    if node_deps:
+        # Covers the codeboarding-setup -> run_install path, which bypasses ensure_tools().
+        ensure_node_runtime(target_dir=target, auto_install_npm=auto_install_npm)
 
     # Compute a unified total so the caller sees a single progress stream.
-    native_count = sum(1 for d in TOOL_REGISTRY if d.kind is ToolKind.NATIVE and d.source)
-    node_deps = [d for d in TOOL_REGISTRY if d.kind is ToolKind.NODE]
-    archive_count = sum(1 for d in TOOL_REGISTRY if d.kind is ToolKind.ARCHIVE)
-    pm_count = sum(1 for d in TOOL_REGISTRY if d.kind is ToolKind.PACKAGE_MANAGER)
-    npm_available = resolve_npm_availability(auto_install_npm=auto_install_npm, target_dir=target)
-    total_steps = native_count + (1 if npm_available and node_deps else 0) + archive_count + pm_count
+    native_count = sum(1 for d in selected if d.kind is ToolKind.NATIVE and d.source)
+    archive_count = sum(1 for d in selected if d.kind is ToolKind.ARCHIVE)
+    pm_count = sum(1 for d in selected if d.kind is ToolKind.PACKAGE_MANAGER)
+    npm_available = bool(node_deps) and resolve_npm_availability(auto_install_npm=auto_install_npm, target_dir=target)
+    total_steps = native_count + (1 if npm_available else 0) + archive_count + pm_count
 
     step = 0
 
@@ -770,14 +722,18 @@ def run_install(
     tracker = unified_progress if on_progress else None
 
     if npm_available:
-        install_node_servers(target, on_progress=tracker)
-
-    download_binaries(target, auto_install_vcpp=auto_install_vcpp, on_progress=tracker)
-    download_jdtls(target, on_progress=tracker)
-    install_package_manager_lsp_servers(target, on_progress=tracker)
-    download_grammars(target)
+        install_node_servers(target, on_progress=tracker, deps=selected)
+
+    if native_count:
+        download_binaries(target, auto_install_vcpp=auto_install_vcpp, on_progress=tracker, deps=selected)
+    if archive_count:
+        download_jdtls(target, on_progress=tracker, deps=selected)
+    install_package_manager_lsp_servers(target, on_progress=tracker, deps=selected)
+    if any(d.key == "kotlin" for d in selected):
+        download_grammars(target)
     install_pre_commit_hooks()
-    print_language_support_summary(npm_available, target)
+    if all(dep in selected for dep in TOOL_REGISTRY):
+        print_language_support_summary(npm_available, target)
 
 
 def main() -> None:
@@ -808,5 +764,100 @@ def main() -> None:
     print("  codeboarding full --local /path/to/repo")
 
 
+def _language_checks_from_registry(target_dir: Path) -> list[LanguageSupportCheck]:
+    """Build one LanguageSupportCheck per LSP language listed in VSCODE_CONFIG.
+
+    Data-driven so adding a language to TOOL_REGISTRY + VSCODE_CONFIG
+    automatically flows to the setup summary — no second list to keep in sync.
+    Each tool dep can surface multiple display languages (e.g. the
+    ``typescript`` entry covers both TypeScript and JavaScript).
+    """
+    target_dir = target_dir.resolve()
+    # native/package-manager installers already warn-and-skip on unsupported
+    # hosts; the summary should mirror that instead of crashing when the host has
+    # no ``platform_bin_dir`` layout.
+    try:
+        platform_bin_dir: Path | None = get_platform_bin_dir(target_dir)
+    except RuntimeError:
+        platform_bin_dir = None
+    is_win = platform.system() == "Windows"
+    node_ext = ".cmd" if is_win else ""
+    native_ext = ".exe" if is_win else ""
+    npm_missing = "npm not available"
+
+    checks: list[LanguageSupportCheck] = []
+    lsp_servers = VSCODE_CONFIG.get("lsp_servers", {})
+
+    for dep in TOOL_REGISTRY:
+        if dep.config_section != ConfigSection.LSP_SERVERS:
+            continue
+        config_entry = lsp_servers.get(dep.key)
+        if config_entry is None:
+            continue
+        languages: list[str] = list(config_entry.get("languages", []) or [dep.key])
+
+        paths: list[Path] = []
+        fallback_available = False
+        requires_npm = False
+        reason_requirement = f"{dep.binary_name} not installed"
+        reason_binary = f"{dep.binary_name} binary not found"
+
+        if dep.kind is ToolKind.NATIVE:
+            if platform_bin_dir is not None:
+                paths.append(platform_bin_dir / f"{dep.binary_name}{native_ext}")
+            else:
+                reason_requirement = f"{dep.binary_name} unavailable on this platform"
+                reason_binary = reason_requirement
+        elif dep.kind is ToolKind.NODE:
+            requires_npm = True
+            reason_requirement = npm_missing
+            paths.append(target_dir / "node_modules" / ".bin" / f"{dep.binary_name}{node_ext}")
+            # Python pyright also resolves from the active environment.
+            if dep.key == "python":
+                env_path = shutil.which("pyright-langserver") or shutil.which("pyright-python-langserver")
+                fallback_available = bool(env_path)
+                reason_requirement = "pyright-langserver not found in node_modules or active environment"
+                reason_binary = reason_requirement
+        elif dep.kind is ToolKind.ARCHIVE:
+            # An archive is validated by its launcher, or for JDTLS by directory
+            # presence (+ plugins/ subdir), mirroring has_required_tools.
+            subdir = dep.archive_subdir or dep.key
+            paths.append(archive_launcher_path(target_dir, dep) or target_dir / "bin" / subdir)
+            reason_requirement = f"{subdir} installation not found"
+            reason_binary = reason_requirement
+            # Java analysis can still proceed when a system Java 21+ is available
+            # (jdtls's bundled JRE is the default, but not strictly required).
+            if dep.key == "java":
+                fallback_available = bool(find_java_21_or_later())
+                reason_binary = "jdtls or Java 21+ not found"
+        elif dep.kind is ToolKind.PACKAGE_MANAGER:
+            pm_path = package_manager_tool_path(target_dir, dep)
+            if pm_path is not None:
+                paths.append(pm_path)
+            manager = (
+                dep.source.manager_binary if isinstance(dep.source, PackageManagerToolSource) else "package manager"
+            )
+            if pm_path is None:
+                reason_requirement = f"{dep.binary_name} unavailable on this platform"
+            else:
+                reason_requirement = f"{dep.binary_name} not installed ({manager} unavailable or install failed)"
+            reason_binary = reason_requirement
+
+        health_check = check_rust_toolchain if dep.key == "rust" else None
+        for lang in languages:
+            checks.append(
+                LanguageSupportCheck(
+                    language=lang,
+                    paths=list(paths),
+                    requires_npm=requires_npm,
+                    fallback_available=fallback_available,
+                    reason_if_requirement_missing=reason_requirement,
+                    reason_if_binary_missing=reason_binary,
+                    health_check=health_check,
+                )
+            )
+    return checks
+
+
 if __name__ == "__main__":
     main()

{codeboarding-0.15.2 → codeboarding-0.15.3}/infra/tool_registry/__init__.py

@@ -4,6 +4,8 @@ Layered: registry (data) -> paths -> manifest / installers -> __init__ (re-expor
 """
 
 from .registry import (  # noqa: F401
+    ALL_LANGUAGE_KEYS,
+    BASE_TOOL_KEYS,
     JDTLS_BUILD,
     JDTLS_URL_TEMPLATE,
     JDTLS_VERSION,
@@ -50,11 +52,11 @@ from .manifest import (  # noqa: F401
     installed_version,
     manifest_path,
     needs_install,
-    npm_specs_fingerprint,
     read_manifest,
     resolve_config,
     resolve_config_from_path,
-    tools_fingerprint,
+    required_tools,
+    tool_fingerprint,
     write_manifest,
 )
 from .installers import (  # noqa: F401