codeboarding 0.15.0__tar.gz → 0.15.2__tar.gz

{codeboarding-0.15.0 → codeboarding-0.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.15.0
+Version: 0.15.2
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

{codeboarding-0.15.0 → codeboarding-0.15.2}/agents/llm_errors.py

@@ -1,17 +1,4 @@
-"""Provider-agnostic detection and typing of LLM authentication failures.
-
-A rejected API key (HTTP 401, or a provider's equivalent auth/permission
-error) is *permanent* for the run: retrying it wastes minutes of backoff and
-floods telemetry with identical ``$exception`` events. The agent retry loop and
-the CLI both need to recognize one when they see it, regardless of which SDK
-raised it.
-
-``detect_auth_error`` maps a raw provider exception to an :class:`LLMAuthError`
-(or ``None`` when it isn't an auth failure). The typed error carries the
-provider, a masked key tail, and the provider's own message, and forwards them
-as ``telemetry_properties`` so the PostHog ``$exception`` event — and the
-dashboard's structured ``error`` columns — populate instead of staying null.
-"""
+"""Provider-agnostic LLM failure classification, exceptions, and retry helpers."""
 
 from __future__ import annotations
 
@@ -33,6 +20,11 @@ EXIT_AUTH_ERROR = 2
 # Process exit code for an exhausted token or credit quota: the key is fine, the account is not.
 EXIT_QUOTA_EXHAUSTED = 3
 
+CODEBOARDING_QUOTA_CODE = "free_credits_exhausted"
+# Response contract: licensing-aws/gha_proxy/handler.py.
+PROXY_ERROR_TYPE = "gha_proxy"
+PROXY_QUOTA_MESSAGE = "Resource exhausted: token limit reached"
+
 # Class names, across SDKs, that always mean "credentials were rejected".
 # openai/anthropic/cerebras raise ``AuthenticationError``; google raises
 # ``Unauthenticated``/``PermissionDenied``; Bedrock (botocore) surfaces
@@ -114,6 +106,65 @@ class LLMAuthError(RuntimeError):
         self.telemetry_properties = telemetry_properties
 
 
+class LLMQuotaError(RuntimeError):
+    """An LLM quota is exhausted, with recovery guidance and failure telemetry."""
+
+    def __init__(self, error: BaseException):
+        self.telemetry_properties = llm_failure_properties(error)
+        self.is_codeboarding_quota = _is_codeboarding_quota(error)
+        _, key_tail = current_provider_key_context()
+        if self.is_codeboarding_quota:
+            message = (
+                "Your CodeBoarding quota is exhausted. "
+                "Buy a CodeBoarding license at https://codeboarding.org/pricing, "
+                "or wait for your weekly reset."
+            )
+        elif key_tail == CODEBOARDING_KEY_TAIL:
+            message = (
+                "The hosted LLM provider's quota is exhausted. "
+                "This is a CodeBoarding service issue. Please try again later or contact CodeBoarding support."
+            )
+        else:
+            message = (
+                "The LLM provider's token or credit quota is exhausted. "
+                "Add credits or raise the quota for this provider, then re-run."
+            )
+        super().__init__(message)
+
+
+def llm_failure_properties(exc: BaseException) -> dict:
+    """Classify a failed LLM call for exception telemetry."""
+    quota = is_quota_exhausted(exc)
+    context = isinstance(exc, ScopeContextTooLargeError) or any(p.search(str(exc)) for p in _CONTEXT_OVERFLOW_PATTERNS)
+    provider, _key_tail = current_provider_key_context()
+    properties = {
+        "error_type": "quota" if quota else "context" if context else "llm",
+        "error_provider": provider,
+        "error_status_code": _status_code(exc),
+        "error_message": str(exc)[:500],
+    }
+    if _is_codeboarding_quota(exc):
+        properties["error_code"] = CODEBOARDING_QUOTA_CODE
+    return properties
+
+
+def is_quota_exhausted(exc: BaseException) -> bool:
+    status = _status_code(exc)
+    quota_code = getattr(exc, "code", None) == "insufficient_quota" or "insufficient_quota" in str(exc)
+    return status == 402 or (status == 429 and quota_code)
+
+
+def _is_codeboarding_quota(exc: BaseException) -> bool:
+    body = getattr(exc, "body", {})
+    error = body.get("error", body) if isinstance(body, dict) else {}
+    return (
+        _status_code(exc) == 402
+        and isinstance(error, dict)
+        and error.get("type") == PROXY_ERROR_TYPE
+        and error.get("message") == PROXY_QUOTA_MESSAGE
+    )
+
+
 def _status_code(exc: BaseException) -> int | None:
     code = getattr(exc, "status_code", None)
     if code is None:
@@ -183,30 +234,6 @@ def detect_auth_error(exc: BaseException, *, provider: str, key_tail: str) -> LL
     )
 
 
-def _is_quota_exhausted(exc: BaseException) -> bool:
-    status = _status_code(exc)
-    quota_code = getattr(exc, "code", None) == "insufficient_quota" or "insufficient_quota" in str(exc)
-    return status == 402 or (status == 429 and quota_code)
-
-
-def llm_failure_properties(exc: BaseException) -> dict:
-    """``$exception`` properties for a failed LLM call, telling an exhausted quota or an oversized prompt
-    apart from other failures.
-
-    Why: the hosted proxy's paywall is a 402, and OpenAI reports an empty balance as a 429 ``insufficient_quota``.
-    An oversized prompt is ours to fix, not the provider's, so it gets its own type on the dashboard.
-    """
-    quota = _is_quota_exhausted(exc)
-    context = isinstance(exc, ScopeContextTooLargeError) or any(p.search(str(exc)) for p in _CONTEXT_OVERFLOW_PATTERNS)
-    provider, _key_tail = current_provider_key_context()
-    return {
-        "error_type": "quota" if quota else "context" if context else "llm",
-        "error_provider": provider,
-        "error_status_code": _status_code(exc),
-        "error_message": str(exc)[:500],
-    }
-
-
 def is_transient_llm_error(exc: BaseException) -> bool:
     """Whether the same request may succeed if sent again: throttled, a server error, or no answer at all.
 
@@ -216,7 +243,7 @@ def is_transient_llm_error(exc: BaseException) -> bool:
     """
     status = _status_code(exc)
     if status is not None:
-        return status in (408, 429) and not _is_quota_exhausted(exc) or status >= 500
+        return status in (408, 429) and not is_quota_exhausted(exc) or status >= 500
     return any(cls.__name__ in _TRANSIENT_TYPE_NAMES for cls in type(exc).__mro__)
 
 

{codeboarding-0.15.0 → codeboarding-0.15.2}/agents/tree_planner_agent.py

@@ -16,7 +16,7 @@ from langchain_core.prompts import PromptTemplate
 from agents.agent_responses import PlannedGroup, TreePlanInsights
 from agents.llm_config import get_current_prompt_profile, supports_json_mode
 from infra.monitoring.callbacks import MONITORING_CALLBACK
-from agents.llm_errors import LLMAuthError, raise_if_auth_error
+from agents.llm_errors import LLMAuthError, LLMQuotaError, is_quota_exhausted, raise_if_auth_error
 from agents.prompts import get_tree_plan_prompts
 from agents.retry import LLM_MAX_ATTEMPTS, RetryAction, RetryDecision, classify_llm_error, with_retries
 from infra.monitoring import trace
@@ -103,7 +103,7 @@ class TreePlannerAgent(MonitoringMixin):
         return folded
 
     def _draw(self, prompt: str, labelled: dict[str, CandidateGroup]) -> list[TreePlanInsights]:
-        """``draws`` answers to one prompt, drawn concurrently; a draw that fails is dropped."""
+        """Draw concurrently, dropping failed draws unless credentials or quota prevent further work."""
         # Not ``with``: its ``__exit__`` waits for a stalled draw; a copied context carries the
         # monitoring step into each worker.
         pool = ThreadPoolExecutor(max_workers=self.draws)
@@ -117,6 +117,8 @@ class TreePlannerAgent(MonitoringMixin):
                 except LLMAuthError:
                     raise
                 except Exception as exc:
+                    if is_quota_exhausted(exc):
+                        raise LLMQuotaError(exc) from exc
                     failures.append(exc)
                     logger.warning("[Planner] draw failed: %s", exc)
         finally:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.15.0
+Version: 0.15.2
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

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

@@ -140,6 +140,7 @@ static_analyzer/node.py
 static_analyzer/programming_language.py
 static_analyzer/scanner.py
 static_analyzer/typescript_config_scanner.py
+static_analyzer/typescript_workspace.py
 static_analyzer/workspace_dependencies.py
 static_analyzer/cfg/__init__.py
 static_analyzer/cfg/call_graph.py
@@ -184,6 +185,8 @@ static_analyzer/engine/adapters/rust_adapter.py
 static_analyzer/engine/adapters/typescript_adapter.py
 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_persisted_analysis_artifacts.py
 tests/test_pyproject_packages.py
 tests/test_view_instructions.py

{codeboarding-0.15.0 → codeboarding-0.15.2}/codeboarding_cli/commands/full_analysis.py

@@ -5,7 +5,8 @@ from pathlib import Path
 from tqdm import tqdm
 
 from agents.llm_config import LLMConfigError
-from agents.llm_errors import LLMAuthError
+from agents.llm_errors import LLMAuthError, LLMQuotaError
+from diagram_analysis.exceptions import ScopeSemanticsError
 from codeboarding_cli.bootstrap import bootstrap_environment, resolve_local_run_paths
 from codeboarding_cli.view_instructions import print_view_instructions
 from codeboarding_workflows.analysis import run_full
@@ -13,7 +14,6 @@ from codeboarding_workflows.orchestration import run_analysis_pipeline
 from codeboarding_workflows.sources import SourceContext, local_source, remote_source
 from infra.constants import CLI_ROOT_DOCUMENT_NAME
 from diagram_analysis import DEFAULT_DEPTH_CAP, RunContext, RunPaths
-from diagram_analysis.exceptions import ScopeSemanticsError
 from infra.monitoring import monitor_execution
 from infra.monitoring.paths import get_monitoring_run_dir
 from output_generators.rendering import render_docs
@@ -161,7 +161,7 @@ def _run_remote(args: argparse.Namespace) -> None:
                 upload=args.upload,
                 should_monitor=should_monitor,
             )
-        except (LLMAuthError, ScopeSemanticsError):
+        except (LLMAuthError, LLMQuotaError, ScopeSemanticsError):
             # The next repository would fail the same way, so stop the run.
             raise
         except Exception:

{codeboarding-0.15.0 → codeboarding-0.15.2}/codeboarding_cli/commands/incremental_analysis.py

@@ -5,12 +5,12 @@ import sys
 from typing import Any
 
 from agents.llm_config import LLMConfigError
-from agents.llm_errors import LLMAuthError
+from agents.llm_errors import LLMAuthError, LLMQuotaError
+from diagram_analysis.exceptions import ScopeSemanticsError
 from codeboarding_cli.bootstrap import bootstrap_environment, resolve_local_run_paths
 from codeboarding_cli.view_instructions import print_view_instructions
 from codeboarding_workflows.analysis import BaselineUnavailableError, run_incremental
 from diagram_analysis import RunContext
-from diagram_analysis.exceptions import ScopeSemanticsError
 from diagram_analysis.run_mode import RunMode
 from infra.utils import monitoring_enabled
 
@@ -61,7 +61,7 @@ def run_from_args(args: argparse.Namespace, parser: argparse.ArgumentParser) ->
         # to prompt for a full run; no stack trace needed.
         logger.info("Incremental unavailable: %s", exc)
         _emit_error(str(exc))
-    except (LLMAuthError, ScopeSemanticsError):
+    except (LLMAuthError, LLMQuotaError, ScopeSemanticsError):
         # A full run would fail the same way, so don't ask for one.
         raise
     except Exception as exc:

{codeboarding-0.15.0 → codeboarding-0.15.2}/codeboarding_cli/main.py

@@ -1,18 +1,20 @@
 import argparse
+import logging
 import os
 import sys
-import traceback
 from pathlib import Path
 
 from agents.llm_config import CODEBOARDING_KEY_TAIL
-from agents.llm_errors import EXIT_AUTH_ERROR, EXIT_QUOTA_EXHAUSTED, LLMAuthError
+from agents.llm_errors import EXIT_AUTH_ERROR, EXIT_QUOTA_EXHAUSTED, LLMAuthError, LLMQuotaError
 from codeboarding_cli.bootstrap import resolve_local_run_paths
 from codeboarding_cli.commands import full_analysis, incremental_analysis, partial_analysis
-from diagram_analysis.exceptions import ScopeSemanticsError
 from output_generators import SUPPORTED_FORMATS, render as render_output
 from infra.utils import ANALYSIS_FILENAME
 
 _SUBCOMMANDS = {"full", "incremental", "partial"}
+# CodeBoarding-action/scripts/analyze_repository.py parses this prefix; keep it stable.
+_ERROR_PREFIX = "CodeBoarding: "
+logger = logging.getLogger(__name__)
 
 
 def _build_shared_parser() -> argparse.ArgumentParser:
@@ -108,22 +110,15 @@ def _dispatch(args: argparse.Namespace, parser: argparse.ArgumentParser) -> None
                     output_dir=run_paths.output_dir,
                 )
     except LLMAuthError as exc:
-        # A rejected API key is the user's to fix, not a crash: print one
-        # actionable line (no traceback) and exit with a distinct code.
-        print(f"\nCodeBoarding: {exc}", file=sys.stderr)
+        logger.error("%s%s", _ERROR_PREFIX, exc)
         if exc.key_tail != CODEBOARDING_KEY_TAIL:
-            print(
+            logger.error(
                 "Check your LLM provider API key (shell env or ~/.codeboarding/config.toml) and re-run.",
-                file=sys.stderr,
             )
         raise SystemExit(EXIT_AUTH_ERROR) from exc
-    except ScopeSemanticsError as exc:
-        if exc.telemetry_properties.get("error_type") != "quota":
-            raise
-        # Same exit as any failure, but with a code callers (the GitHub Action) can name.
-        traceback.print_exception(exc)
-        print("\nCodeBoarding: the LLM provider's token or credit quota is exhausted.", file=sys.stderr)
-        print("Add credits or raise the quota for this provider, then re-run.", file=sys.stderr)
+    except LLMQuotaError as exc:
+        logger.exception("LLM quota failure")
+        logger.error("%s%s", _ERROR_PREFIX, exc)
         raise SystemExit(EXIT_QUOTA_EXHAUSTED) from exc
 
 

{codeboarding-0.15.0 → codeboarding-0.15.2}/diagram_analysis/diagram_generator.py

@@ -30,7 +30,7 @@ from diagram_analysis.incremental_update import (
 from agents.incremental_results import RecursiveScopeUpdateResult
 from agents.file_index_models import FileEntry, FileMethodGroup, MethodEntry
 from agents.llm_config import initialize_agent_llm
-from agents.llm_errors import LLMAuthError, llm_failure_properties
+from agents.llm_errors import LLMAuthError, LLMQuotaError, is_quota_exhausted, llm_failure_properties
 from agents.relation_edges import (
     drop_misattributed_edges,
     index_relation_endpoints,
@@ -818,9 +818,11 @@ class DiagramGenerator:
                 incremental,
                 enclosing_names=enclosing_names,
             )
-        except LLMAuthError:
+        except (LLMAuthError, LLMQuotaError, ScopeSemanticsError):
             raise
         except Exception as error:
+            if is_quota_exhausted(error):
+                raise LLMQuotaError(error) from error
             raise ScopeSemanticsError(scope.scope_id, telemetry_properties=llm_failure_properties(error)) from error
         if semantics is None:
             with self._naming_counts_lock:
@@ -1120,7 +1122,7 @@ class DiagramGenerator:
             new_components = [child for child in analysis.components if child.component_id in preclustered_scopes]
 
             return component.component_id, analysis, new_components
-        except (LLMAuthError, ScopeSemanticsError):
+        except (LLMAuthError, LLMQuotaError, ScopeSemanticsError):
             # An LLM failure aborts the whole run rather than shipping this component with deterministic names.
             raise
         except Exception:
@@ -1335,7 +1337,7 @@ class DiagramGenerator:
                     stats["completed"] += 1
                     try:
                         outcomes.append((component, level, future.result()))
-                    except (LLMAuthError, ScopeSemanticsError):
+                    except (LLMAuthError, LLMQuotaError, ScopeSemanticsError):
                         for pending in future_to_task:
                             pending.cancel()
                         raise

{codeboarding-0.15.0 → codeboarding-0.15.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codeboarding"
-version = "0.15.0"
+version = "0.15.2"
 description = "Interactive Diagrams for Code"
 readme = "PYPI.md"
 license = "MIT"
@@ -106,6 +106,10 @@ packages = [
 ]
 include-package-data = true
 
+[tool.setuptools.package-data]
+# tsserver loads a plugin only from <location>/node_modules/<name>.
+static_analyzer = ["typescript_plugin/node_modules/codeboarding-workspace-sources/*"]
+
 [project.scripts]
 codeboarding = "codeboarding_cli.main:main"
 codeboarding-setup = "infra.install:main"

{codeboarding-0.15.0 → codeboarding-0.15.2}/static_analyzer/__init__.py

@@ -363,6 +363,10 @@ class StaticAnalyzer:
                 continue
             try:
                 started.append((engine_config, self._spawn_engine_client(engine_config)))
+            except StaticAnalysisFatalError:
+                for _, client in started:  # never handed to ``stop_clients``
+                    client.shutdown()
+                raise
             except Exception as exc:
                 logger.exception(
                     f"Failed to start engine LSP client for {adapter.language}; "
@@ -500,6 +504,7 @@ class StaticAnalyzer:
             extra_client_capabilities=getattr(adapter, "extra_client_capabilities", {}) or {},
             error_verdict=adapter.error_verdict,
             workspace_folders=workspace_folders,
+            commands=adapter.get_lsp_commands(project_path),
         )
         try:
             engine_client.start()
@@ -918,6 +923,12 @@ class StaticAnalyzer:
             adapter, project_path = engine_config.adapter, engine_config.project_path
             language = adapter.results_language
             changed_files = self._changed_files_for_language(project_path, cached_sha, adapter.language)
+            if changed_files is not None and adapter.rebuilds_for(changed_files, project_path):
+                logger.info(f"warmstart {adapter.language}: a change alters how imports resolve; rebuilding")
+                changed_files = None
+                if resident_client is not None:
+                    # Why: a server resolves imports as the project was when it started; a stopped one is replaced.
+                    resident_client.shutdown()
             # A full re-analysis is the full pass's, so a split config runs as its parts. Changed files stay on the
             # config's own server: tsserver loads only the projects of the files it opens.
             if changed_files is None:

{codeboarding-0.15.0 → codeboarding-0.15.2}/static_analyzer/analysis_cache.py

@@ -74,8 +74,9 @@ _LEGACY_CACHE_SUBDIR = "cache"
 # v11: every language builds its call edges from definitions at the call site.
 # v12: a large TypeScript monorepo runs one server per tsconfig project, so a graph one out-of-memory
 # server left without edges is rebuilt; bases, implementations and edge-only declarations link across engines.
+# v13: a TypeScript call into a sibling workspace package resolves to its sources without an install or build.
 # Older pickles are treated as cache misses and re-run.
-_TAG_VERSION = "v12"
+_TAG_VERSION = "v13"
 
 
 class StaticAnalysisCache:

{codeboarding-0.15.0 → codeboarding-0.15.2}/static_analyzer/engine/adapters/typescript_adapter.py

@@ -2,11 +2,18 @@
 
 from __future__ import annotations
 
+import logging
+import re
+from collections.abc import Collection
 from pathlib import Path
 
 from infra.repo_utils.ignore import RepoIgnoreManager
 from static_analyzer.config import Language
 from static_analyzer.engine.language_adapter import LanguageAdapter
+from static_analyzer.exceptions import WorkspaceSetupError
+from static_analyzer.typescript_workspace import PLUGIN_LOCATION, PLUGIN_NAME, workspace_members
+
+logger = logging.getLogger(__name__)
 
 
 class TypeScriptAdapter(LanguageAdapter):
@@ -34,7 +41,30 @@ class TypeScriptAdapter(LanguageAdapter):
     def get_lsp_init_options(self, ignore_manager: RepoIgnoreManager | None = None) -> dict:
         # Why: by default a syntax-only server answers while the project still loads, and a definition
         # that needs an inferred type -- ``.then(t => t.serialize())`` -- comes back empty on a cold start.
-        return {"tsserver": {"useSyntaxServer": "never"}}
+        # Why the plugin: a call into a sibling workspace package of an uninstalled, unbuilt checkout resolves nowhere;
+        # the plugin resolves it to the member's sources (see ``typescript_workspace``).
+        return {
+            "tsserver": {"useSyntaxServer": "never"},
+            "plugins": [{"name": PLUGIN_NAME, "location": str(PLUGIN_LOCATION)}],
+        }
+
+    def get_lsp_commands(self, project_root: Path) -> list[dict]:
+        """Hands the workspace members to the plugin; tsserver gives the configuration to each project it loads."""
+        members = workspace_members(project_root)
+        if not members:
+            return []
+        if not (PLUGIN_LOCATION / "node_modules" / PLUGIN_NAME / "index.js").is_file():
+            raise WorkspaceSetupError(f"{PLUGIN_NAME} is missing from this install; reinstall CodeBoarding")
+        logger.info(f"tsserver resolves {len(members)} workspace members of {project_root} to their sources")
+        configuration = {"root": str(project_root), "members": {name: str(path) for name, path in members.items()}}
+        return [{"command": "_typescript.configurePlugin", "arguments": [PLUGIN_NAME, configuration]}]
+
+    def rebuilds_for(self, changed_files: Collection[Path], project_root: Path) -> bool:
+        """Whether a change alters how imports resolve: a tsconfig, a workspace declaration, or a workspace's manifest."""
+        names = {path.name for path in changed_files}
+        if "pnpm-workspace.yaml" in names or any(re.fullmatch(r"[tj]sconfig.*\.json", name) for name in names):
+            return True
+        return "package.json" in names and bool(workspace_members(project_root))
 
     def get_lsp_heap_options(self, heap_bytes: int) -> dict:
         # Why: at Node's default heap tsserver runs out of memory on a large tsconfig project and answers nothing.

{codeboarding-0.15.0 → codeboarding-0.15.2}/static_analyzer/engine/language_adapter.py

@@ -271,6 +271,14 @@ class LanguageAdapter(ABC):
         """
         return {}
 
+    def get_lsp_commands(self, project_root: Path) -> list[dict]:
+        """``workspace/executeCommand`` params the server is sent once initialized, and again on a restart."""
+        return []
+
+    def rebuilds_for(self, changed_files: Collection[Path], project_root: Path) -> bool:
+        """Whether a warm start over *changed_files* must re-analyse the whole project on a fresh server."""
+        return False
+
     def workspace_folders(self, project_root: Path, source_files: Sequence[Path]) -> list[Path]:
         """Workspace folders to announce to the server in place of the project, or none."""
         return []

{codeboarding-0.15.0 → codeboarding-0.15.2}/static_analyzer/engine/lsp_client.py

@@ -21,7 +21,7 @@ from pathlib import Path
 from static_analyzer.config import LANGUAGE_ID_BY_SUFFIX
 from static_analyzer.engine.lsp_constants import REQUEST_BATCH_SIZE
 from static_analyzer.engine.utils import uri_to_path
-from static_analyzer.exceptions import LanguageServerStalledError, StaticAnalysisFatalError
+from static_analyzer.exceptions import LanguageServerStalledError, StaticAnalysisFatalError, WorkspaceSetupError
 from static_analyzer.lsp_client.diagnostics import FileDiagnosticsMap, LSPDiagnostic
 
 logger = logging.getLogger(__name__)
@@ -113,6 +113,7 @@ class LSPClient:
         extra_client_capabilities: dict | None = None,
         error_verdict: Callable[[dict], ErrorVerdict] | None = None,
         workspace_folders: list[Path] | None = None,
+        commands: list[dict] | None = None,
     ) -> None:
         self._command = command
         self._project_root = project_root
@@ -129,6 +130,7 @@ class LSPClient:
         self._error_verdict = error_verdict
         # Announced in place of the project folder, for a server handed a workspace described apart from it.
         self._workspace_folders = workspace_folders or []
+        self._commands = commands or []
         self._process: subprocess.Popen | None = None  # type: ignore[type-arg]
         self._stdout_fd: int | None = None
         self._request_id = 0
@@ -257,6 +259,8 @@ class LSPClient:
         if isinstance(init_result, dict):
             self._server_capabilities = init_result.get("capabilities") or {}
         self._send_notification("initialized", {})
+        for command in self._commands:
+            self._send_request("workspace/executeCommand", command, timeout=self._default_timeout, required=True)
 
         # LSP servers receive configuration through three mechanisms:
         #   1. initializationOptions  — sent in the initialize request above.
@@ -706,8 +710,10 @@ class LSPClient:
             answers.append(BatchAnswer(parsed, req_id not in unserved, req_id in retryable))
         return answers
 
-    def _send_request(self, method: str, params: dict | list | None, timeout: int) -> dict | list | None:
-        """Send a JSON-RPC request and wait for the response."""
+    def _send_request(
+        self, method: str, params: dict | list | None, timeout: int, required: bool = False
+    ) -> dict | list | None:
+        """Send a JSON-RPC request and wait for the response; a *required* one that does not succeed is fatal."""
         if self.server_failure:
             self.check_alive()
         self._request_id += 1
@@ -731,6 +737,8 @@ class LSPClient:
 
             if "error" in msg:
                 error = msg["error"]
+                if required:
+                    raise WorkspaceSetupError(f"The language server rejected {method} {params}: {error}")
                 if isinstance(error, dict) and error.get("code") == LSP_METHOD_NOT_FOUND:
                     raise MethodNotFoundError(error.get("message", "Method not found"))
                 logger.warning("LSP error for request %d (%s): %s", req_id, method, error)
@@ -742,6 +750,8 @@ class LSPClient:
                 return None
             return msg.get("result")
 
+        if required:
+            raise WorkspaceSetupError(f"The language server did not answer {method} {params} within {timeout}s")
         raise TimeoutError(f"Timeout waiting for LSP response to request {req_id}")
 
     def _send_notification(self, method: str, params: dict | list | None) -> None:

{codeboarding-0.15.0 → codeboarding-0.15.2}/static_analyzer/exceptions.py

@@ -5,5 +5,9 @@ class StaticAnalysisFatalError(RuntimeError):
     """Raised when continuing would produce misleading cached analysis."""
 
 
+class WorkspaceSetupError(StaticAnalysisFatalError):
+    """Raised when the workspace a language server must be set up with cannot be, so its answers would miss edges."""
+
+
 class LanguageServerStalledError(StaticAnalysisFatalError):
     """Raised when a language server stays up but the backend that answers for it has died."""