codeboarding 0.14.5__tar.gz → 0.15.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.14.5
+Version: 0.15.0
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT
@@ -52,6 +52,7 @@ Requires-Dist: tree-sitter-c-sharp==0.23.5
 Requires-Dist: tree-sitter-go==0.25.0
 Requires-Dist: tree-sitter-java==0.23.5
 Requires-Dist: tree-sitter-javascript==0.25.0
+Requires-Dist: tree-sitter-language-pack==1.21.0
 Requires-Dist: tree-sitter-php==0.24.1
 Requires-Dist: tree-sitter-python==0.25.0
 Requires-Dist: tree-sitter-rust==0.24.2
@@ -84,13 +85,14 @@ Dynamic: license-file
 - Builds layered abstractions with an LLM agent (OpenAI, Anthropic, Google Gemini, Ollama, and more)
 - Outputs Mermaid.js diagrams ready for docs, IDEs, and CI/CD pipelines
 
-**Supported languages:** Python · TypeScript · JavaScript · Java · Go · PHP
+**Supported languages:** Python · TypeScript · JavaScript · Java · Kotlin · Go · PHP
 
 ---
 
 ## Requirements
 
 - **Python 3.12 or 3.13** — other versions are currently not supported.
+- **Linux:** glibc 2.34 or newer (Ubuntu 22.04, Debian 12, RHEL 9 or later), for the Kotlin parser.
 
 ## Installation
 

{codeboarding-0.14.5 → codeboarding-0.15.0}/PYPI.md

@@ -11,13 +11,14 @@
 - Builds layered abstractions with an LLM agent (OpenAI, Anthropic, Google Gemini, Ollama, and more)
 - Outputs Mermaid.js diagrams ready for docs, IDEs, and CI/CD pipelines
 
-**Supported languages:** Python · TypeScript · JavaScript · Java · Go · PHP
+**Supported languages:** Python · TypeScript · JavaScript · Java · Kotlin · Go · PHP
 
 ---
 
 ## Requirements
 
 - **Python 3.12 or 3.13** — other versions are currently not supported.
+- **Linux:** glibc 2.34 or newer (Ubuntu 22.04, Debian 12, RHEL 9 or later), for the Kotlin parser.
 
 ## Installation
 

{codeboarding-0.14.5 → codeboarding-0.15.0}/README.md

@@ -17,6 +17,7 @@ The example starts with a large pull-request diff, then shows the six components
 [![JavaScript](https://img.shields.io/badge/JavaScript-222222?style=flat-square&logo=javascript&logoColor=F7DF1E)](https://developer.mozilla.org/en-US/docs/Web/JavaScript)
 [![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?style=flat-square&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
 [![Java](https://img.shields.io/badge/Java-E76F00?style=flat-square&logo=openjdk&logoColor=white)](https://www.java.com/)
+[![Kotlin](https://img.shields.io/badge/Kotlin-7F52FF?style=flat-square&logo=kotlin&logoColor=white)](https://kotlinlang.org/)
 [![Python](https://img.shields.io/badge/Python-3776AB?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
 [![Go](https://img.shields.io/badge/Go-00ADD8?style=flat-square&logo=go&logoColor=white)](https://go.dev/)
 [![PHP](https://img.shields.io/badge/PHP-777BB4?style=flat-square&logo=php&logoColor=white)](https://www.php.net/)
@@ -103,8 +104,8 @@ git clone https://github.com/CodeBoarding/CodeBoarding.git
 cd CodeBoarding
 uv sync --frozen
 source .venv/bin/activate  # On Windows: .venv\Scripts\activate
-python install.py
-python main.py full --local /path/to/repo
+python -m infra.install
+python -m codeboarding_cli.main full --local /path/to/repo
 ```
 
 ### Use the packaged CLI
@@ -152,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 install.py` 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.
+`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.
 
 ## Configuration
 
@@ -184,32 +185,33 @@ On first run, CodeBoarding creates `~/.codeboarding/config.toml`. Set one provid
 
 Shell environment variables such as `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GOOGLE_API_KEY`, and `OLLAMA_BASE_URL` take precedence over the config file. For private repositories, set `GITHUB_TOKEN` in your environment.
 
-Two environment variables tune the static analysis itself:
+Three environment variables tune the static analysis itself:
 
 | Variable | Effect |
 | --- | --- |
-| `CODEBOARDING_LSP_REQUEST_TIMEOUT` | Seconds a language-server request may block *when it uses the per-language default* (120s for C#, 60s elsewhere). Not a hard cap on every request: the indexing and didOpen-drain probes pass their own scaled budget (60s plus 2s per file, capped at 1800s) and are unaffected. Applies to every language in the run. Unset or empty leaves the defaults alone; any other unusable value fails the run rather than falling back. |
-| `CODEBOARDING_MAX_CONCURRENT_ENGINES` | How many language servers may be resident at once. `0` (the default) leaves the bound off. |
+| `CODEBOARDING_LSP_REQUEST_TIMEOUT` | Seconds a language-server request may block *when it uses the per-language default* (120s for C# and Kotlin, 60s elsewhere). Not a hard cap on every request: `initialize` has its own startup budget (the request default), Kotlin's build import is awaited separately (up to 1800s), and the indexing and didOpen-drain probes pass their own scaled budget (60s plus 2s per file, capped at 1800s); neither is affected. Applies to every language in the run. Unset or empty leaves the defaults alone; any other unusable value fails the run rather than falling back. |
+| `CODEBOARDING_MAX_CONCURRENT_ENGINES` | How many language servers an analysis runs at once. Unset or `0`, the CLI and the GitHub Action run one at a time, each stopped when its language is done, and the editor keeps one per project running. Set, the editor's servers also start only for an analysis, so its file queries are unavailable. |
+| `CODEBOARDING_LSP_MEMORY_BUDGET_MB` | Megabytes the language servers running at once share; tsserver's heap is its share less 512. Unset, it is three quarters of the machine's memory (or of a cgroup v2 container's limit, when lower), at most 12 GB. |
 
 ## Common commands
 
 ```bash
 # Analyze a local repository
-python main.py full --local ./my-project
+python -m codeboarding_cli.main full --local ./my-project
 
 # Raise the depth ceiling to auto-expand deeper (rarely needed — a component that
 # outgrows the leaf ceiling is flagged expandable at whatever depth the run stops
 # and can be expanded on demand; --depth-cap is a safety-valve cap, default 3)
-python main.py full --local ./my-project --depth-cap 5
+python -m codeboarding_cli.main full --local ./my-project --depth-cap 5
 
 # Re-analyze only changed parts when possible
-python main.py incremental --local ./my-project
+python -m codeboarding_cli.main incremental --local ./my-project
 
 # Update a single component by ID
-python main.py partial --local ./my-project --component-id "1.2"
+python -m codeboarding_cli.main partial --local ./my-project --component-id "1.2"
 
 # Analyze a remote GitHub repository
-python main.py full https://github.com/pytorch/pytorch
+python -m codeboarding_cli.main full https://github.com/pytorch/pytorch
 ```
 
 `--depth-cap` configures `metadata.depth_cap`; `metadata.depth_level` records the
@@ -244,7 +246,9 @@ for the actual depth. Existing baseline loading behavior is unchanged: prefer
 
 ## Supported stack
 
-- Languages: Python, TypeScript, JavaScript, Java, Go, PHP, Rust, C#.
+- 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.
 
 ## Examples

{codeboarding-0.14.5 → codeboarding-0.15.0}/agents/agent_responses.py

@@ -8,7 +8,7 @@ from enum import StrEnum
 
 from pydantic import BaseModel, Field
 
-from clustering_ids import ComponentId
+from infra.clustering_ids import ComponentId
 from agents.file_index_models import FileEntry, FileMethodGroup, MethodIndexEntry
 from agents.scope_ids import ROOT_SCOPE_ID
 

{codeboarding-0.14.5 → codeboarding-0.15.0}/agents/content_hash.py

@@ -10,7 +10,7 @@ import os
 from pathlib import Path
 from typing import NamedTuple
 
-from repo_utils.ignore import RepoIgnoreManager
+from infra.repo_utils.ignore import RepoIgnoreManager
 
 SOURCE_ENCODING = "utf-8"
 SOURCE_DECODE_ERRORS = "surrogateescape"

{codeboarding-0.14.5 → codeboarding-0.15.0}/agents/llm_config.py

@@ -15,12 +15,7 @@ from langchain_openai import ChatOpenAI
 from agents.constants import LLMDefaults, ModelCapabilities
 from agents.model_capabilities import ContextWindow, get_context_window
 from agents.prompts import PromptProfile, resolve_prompt_profile
-from monitoring.callbacks import MonitoringCallback
-
-# Initialize global monitoring callback with its own stats container to avoid ContextVar dependency
-from monitoring.stats import RunStats
-
-MONITORING_CALLBACK = MonitoringCallback(stats_container=RunStats())
+from infra.monitoring.callbacks import MONITORING_CALLBACK
 
 logger = logging.getLogger(__name__)
 

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

@@ -15,8 +15,10 @@ dashboard's structured ``error`` columns — populate instead of staying null.
 
 from __future__ import annotations
 
+import email.utils
 import logging
 import re
+import time
 
 from agents.llm_config import CODEBOARDING_KEY_TAIL, current_provider_key_context
 
@@ -62,6 +64,11 @@ _AUTH_MESSAGE_PATTERNS = (
 )
 
 
+# Class names, across SDKs, for a request that never got an answer: openai/anthropic/cerebras raise
+# ``APIConnectionError`` (``APITimeoutError`` subclasses it), ollama lets httpx's ``TransportError`` through.
+_TRANSIENT_TYPE_NAMES = {"APIConnectionError", "TransportError", "TimeoutError", "ConnectionError"}
+
+
 # What each provider says when the prompt is over the model's context window: Google, OpenAI, Anthropic.
 _CONTEXT_OVERFLOW_PATTERNS = (
     re.compile(r"exceeds the maximum number of tokens", re.IGNORECASE),
@@ -111,6 +118,10 @@ def _status_code(exc: BaseException) -> int | None:
     code = getattr(exc, "status_code", None)
     if code is None:
         code = getattr(exc, "code", None)  # google GoogleAPICallError.code
+    if code is None:
+        response = getattr(exc, "response", None)  # botocore ClientError (Bedrock) keeps it in a dict
+        if isinstance(response, dict):
+            code = response.get("ResponseMetadata", {}).get("HTTPStatusCode")
     if code is None:
         return None
     try:
@@ -144,7 +155,11 @@ def detect_auth_error(exc: BaseException, *, provider: str, key_tail: str) -> LL
     status = _status_code(exc)
     provider_message = str(exc)
     status_note = f" (HTTP {status})" if status is not None else ""
-    if key_tail == CODEBOARDING_KEY_TAIL:
+    if status == 403:
+        # A 403 can refuse one request (a router's moderation, a model the key may not use) while the same key
+        # serves the rest, so the provider's own reason says more than a hint about the key.
+        friendly = f"{provider} refused the request (HTTP 403): {provider_message[:500]}"
+    elif key_tail == CODEBOARDING_KEY_TAIL:
         friendly = (
             f"CodeBoarding's hosted {provider} credentials were rejected{status_note}. This run used no key of "
             "yours: check that the workflow grants `id-token: write`, then re-run."
@@ -168,6 +183,12 @@ 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.
@@ -175,18 +196,52 @@ def llm_failure_properties(exc: BaseException) -> dict:
     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.
     """
-    status = _status_code(exc)
-    quota = status == 402 or (status == 429 and "insufficient_quota" in str(exc))
+    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,
+        "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.
+
+    Why: the hosted proxy answers a burst over its concurrency cap with a 429 and a failed upstream call with a
+    502, and one of either used to fail the whole run. A rejected key, a spent quota or a malformed request fails
+    the same way every time.
+    """
+    status = _status_code(exc)
+    if status is not None:
+        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__)
+
+
+def retry_after_seconds(exc: BaseException) -> float | None:
+    """The wait a provider asked for, when the exception carries the response: ``retry-after-ms``, or
+    ``Retry-After`` as seconds or an HTTP date. None when absent, unreadable or already past."""
+    headers = getattr(getattr(exc, "response", None), "headers", None)
+    if headers is None:
+        return None
+    try:
+        return max(0.0, float(headers.get("retry-after-ms", "")) / 1000)
+    except (TypeError, ValueError):
+        pass
+    value = headers.get("retry-after", "")
+    try:
+        return max(0.0, float(value))
+    except (TypeError, ValueError):
+        pass
+    try:
+        wait = email.utils.parsedate_to_datetime(value).timestamp() - time.time()
+    except (TypeError, ValueError):
+        return None
+    return wait if wait > 0 else None
+
+
 def raise_if_auth_error(exc: Exception) -> None:
     """Raise a typed terminal error when a provider rejected its credentials."""
     provider, key_tail = current_provider_key_context()

{codeboarding-0.14.5 → codeboarding-0.15.0}/agents/llm_renderers/scope.py

@@ -12,7 +12,7 @@ from typing import Any
 from agents.agent_responses import AnalysisInsights
 from agents.constants import ModelCapabilities
 from agents.llm_errors import ScopeContextTooLargeError
-from repo_utils.path_utils import normalize_repo_path
+from infra.repo_utils.path_utils import normalize_repo_path
 from static_analyzer.cfg.edge import EdgeKind
 from static_analyzer.clustering import ClusterConnectionEdge, ClusterGroup, ClusterScopeResult
 from static_analyzer.node import Node

{codeboarding-0.14.5 → codeboarding-0.15.0}/agents/model_capabilities.py

@@ -9,7 +9,7 @@ from functools import lru_cache
 from pathlib import Path
 
 from agents.constants import ModelCapabilities
-from utils import get_cache_dir
+from infra.utils import get_cache_dir
 
 logger = logging.getLogger(__name__)
 
@@ -74,7 +74,7 @@ def _resolve_user_config(provider: str, model_name: str) -> tuple[int, int] | No
 def _user_context_window_override() -> int | None:
     # Why: delayed import avoids a module-load cycle; lru_cache avoids re-parsing
     # config.toml on every get_context_window call.
-    from user_config import load_user_config
+    from infra.user_config import load_user_config
 
     return load_user_config().llm.context_window
 

{codeboarding-0.14.5 → codeboarding-0.15.0}/agents/relation_edges.py

@@ -4,8 +4,8 @@ from collections.abc import Callable, Collection
 from pathlib import Path
 
 from agents.agent_responses import AnalysisInsights, Relation, RelationEdge, SourceCodeReference
-from clustering_ids import is_self_or_descendant
-from repo_utils.path_utils import normalize_repo_path
+from infra.clustering_ids import is_self_or_descendant
+from infra.repo_utils.path_utils import normalize_repo_path
 
 
 def append_or_merge_relation(

{codeboarding-0.14.5 → codeboarding-0.15.0}/agents/retry.py

@@ -3,12 +3,15 @@
 from __future__ import annotations
 
 import logging
+import random
 import time
 from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum, auto
 from typing import TypeVar
 
+from agents.llm_errors import is_transient_llm_error, retry_after_seconds
+
 logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
@@ -37,6 +40,29 @@ def default_backoff(attempt: int, *, initial_s: float, multiplier: float, max_s:
     return min(delay, max_s) if max_s is not None else delay
 
 
+#: Attempts per model request. Why these numbers: the full-jitter ceilings run 4, 8, 16 and 32 s, so the
+#: four retries span up to a minute — long enough for a slot to free up behind the hosted proxy's concurrency cap
+#: (one held slot is one model call in flight, often tens of seconds) without doubling a run that is failing anyway.
+LLM_MAX_ATTEMPTS = 5
+LLM_BACKOFF_INITIAL_S = 4.0
+LLM_BACKOFF_MAX_S = 60.0
+
+
+def classify_llm_error(exc: Exception, attempt: int) -> RetryDecision:
+    """Retry a transient provider failure after the wait its ``Retry-After`` asks for, else a full-jitter backoff.
+
+    Why full jitter: the parallel calls one burst throttles would otherwise all retry in the same second and
+    collide again.
+    """
+    if not is_transient_llm_error(exc):
+        return RetryDecision(action=RetryAction.GIVE_UP)
+    delay = retry_after_seconds(exc)
+    if delay is None:
+        ceiling = default_backoff(attempt, initial_s=LLM_BACKOFF_INITIAL_S, multiplier=2.0, max_s=LLM_BACKOFF_MAX_S)
+        delay = random.uniform(0.0, ceiling)
+    return RetryDecision(action=RetryAction.RETRY, backoff_s=min(delay, LLM_BACKOFF_MAX_S))
+
+
 def _default_classify(_exc: Exception, _attempt: int) -> RetryDecision:
     return RetryDecision(action=RetryAction.RETRY)
 

{codeboarding-0.14.5 → codeboarding-0.15.0}/agents/scope_analysis_agent.py

@@ -25,13 +25,15 @@ from pydantic import Field
 
 from agents.agent_responses import AnalysisInsights, LLMBaseModel, RelationEdge, SourceCodeReference
 from agents.constants import ModelCapabilities
-from agents.llm_config import MONITORING_CALLBACK, get_current_agent_context_window, get_current_prompt_profile
+from agents.llm_config import get_current_agent_context_window, get_current_prompt_profile
+from infra.monitoring.callbacks import MONITORING_CALLBACK
 from agents.llm_errors import ScopeContextTooLargeError, raise_if_auth_error
 from agents.llm_renderers import render_scope_context, scope_file_paths, scope_method_names
 from agents.prompts import get_scope_analysis_prompts
+from agents.retry import LLM_MAX_ATTEMPTS, classify_llm_error, with_retries
 from agents.tools import MethodCallsTool, ReadFileTool
 from agents.tools.base import RepoContext
-from monitoring.mixin import MonitoringMixin
+from infra.monitoring.mixin import MonitoringMixin
 from static_analyzer.analysis_result import StaticAnalysisResults
 from static_analyzer.clustering import ClusterScopeResult
 
@@ -159,6 +161,24 @@ class ScopeInputBudget(AgentMiddleware):
             logger.warning("Scope %s: truncating tool result %s to fit context", self.scope_id, message.tool_call_id)
 
 
+class TransientErrorRetry(AgentMiddleware):
+    """Send a model request again when the provider failed it transiently (throttled, 5xx, connection lost).
+
+    Why here: one model request is retried, not the agent run, so the tool calls already made are kept.
+    """
+
+    def __init__(self, scope_id: str):
+        self.scope_id = scope_id
+
+    def wrap_model_call(self, request: ModelRequest, handler: Callable[[ModelRequest], ModelResponse]) -> ModelResponse:
+        return with_retries(
+            lambda: handler(request),
+            max_attempts=LLM_MAX_ATTEMPTS,
+            classify=classify_llm_error,
+            log_prefix=f"Scope {self.scope_id} model call",
+        )
+
+
 class ScopeAnalysisAgent(MonitoringMixin):
     """Analyze any deterministic scope with two scope-restricted tools."""
 
@@ -209,6 +229,7 @@ class ScopeAnalysisAgent(MonitoringMixin):
             RepositoryToolBudget(run_limit=MAX_SCOPE_TOOL_CALLS, exit_behavior="continue"),
             ModelCallLimitMiddleware(run_limit=MAX_SCOPE_MODEL_CALLS, exit_behavior="error"),
             input_budget,
+            TransientErrorRetry(scope.scope_id),
         ]
         agent: CompiledStateGraph = create_agent(
             model=self.agent_llm,

codeboarding-0.15.0/agents/scope_ids.py

@@ -0,0 +1,3 @@
+from infra.clustering_ids import ROOT_SCOPE_ID
+
+__all__ = ["ROOT_SCOPE_ID"]

{codeboarding-0.14.5 → codeboarding-0.15.0}/agents/tools/read_file.py

@@ -4,7 +4,7 @@ from langchain_core.tools import ArgsSchema
 from pydantic import BaseModel, Field
 
 from agents.tools.base import BaseRepoTool
-from repo_utils.path_utils import normalize_repo_path
+from infra.repo_utils.path_utils import normalize_repo_path
 
 logger = logging.getLogger(__name__)
 

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

@@ -3,6 +3,7 @@
 import json
 import logging
 import re
+import time
 from collections import Counter
 from collections.abc import Sequence
 from concurrent.futures import ThreadPoolExecutor
@@ -13,12 +14,13 @@ from langchain_core.messages import HumanMessage, SystemMessage
 from langchain_core.prompts import PromptTemplate
 
 from agents.agent_responses import PlannedGroup, TreePlanInsights
-from agents.llm_config import MONITORING_CALLBACK, get_current_prompt_profile, supports_json_mode
+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.prompts import get_tree_plan_prompts
-from agents.retry import RetryAction, RetryDecision, default_backoff, with_retries
-from monitoring import trace
-from monitoring.mixin import MonitoringMixin
+from agents.retry import LLM_MAX_ATTEMPTS, RetryAction, RetryDecision, classify_llm_error, with_retries
+from infra.monitoring import trace
+from infra.monitoring.mixin import MonitoringMixin
 from static_analyzer.clustering.names import CandidateGroup, GroupingContext, KinshipGrouper, stem, tokenize
 from static_analyzer.clustering.names.draft import GUARD_SHARE, MIN_UNITS
 from static_analyzer.clustering.names.frontier import Candidate
@@ -135,15 +137,21 @@ class TreePlannerAgent(MonitoringMixin):
                 raise ValueError("planner returned malformed JSON")
             return insights
 
+        # Why: ``_draw`` stops waiting after DRAW_TIMEOUT_SECONDS but cannot stop this worker, so no new
+        # attempt starts once the draw has been abandoned.
+        deadline = time.monotonic() + DRAW_TIMEOUT_SECONDS
+
         def classify(exc: Exception, attempt: int) -> RetryDecision:
             raise_if_auth_error(exc)
             if isinstance(exc, ValueError):
-                return RetryDecision(action=RetryAction.RETRY_NOW)
-            return RetryDecision(
-                action=RetryAction.RETRY, backoff_s=default_backoff(attempt, initial_s=10.0, multiplier=2.0, max_s=60.0)
-            )
-
-        return with_retries(once, max_attempts=3, classify=classify, log_prefix="Planner draw")
+                decision = RetryDecision(action=RetryAction.RETRY_NOW)
+            else:
+                decision = classify_llm_error(exc, attempt)
+            if time.monotonic() + decision.backoff_s >= deadline:
+                return RetryDecision(action=RetryAction.GIVE_UP)
+            return decision
+
+        return with_retries(once, max_attempts=LLM_MAX_ATTEMPTS, classify=classify, log_prefix="Planner draw")
 
     @staticmethod
     def _read(text: str, labelled: dict[str, CandidateGroup]) -> TreePlanInsights | None:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.14.5
+Version: 0.15.0
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT
@@ -52,6 +52,7 @@ Requires-Dist: tree-sitter-c-sharp==0.23.5
 Requires-Dist: tree-sitter-go==0.25.0
 Requires-Dist: tree-sitter-java==0.23.5
 Requires-Dist: tree-sitter-javascript==0.25.0
+Requires-Dist: tree-sitter-language-pack==1.21.0
 Requires-Dist: tree-sitter-php==0.24.1
 Requires-Dist: tree-sitter-python==0.25.0
 Requires-Dist: tree-sitter-rust==0.24.2
@@ -84,13 +85,14 @@ Dynamic: license-file
 - Builds layered abstractions with an LLM agent (OpenAI, Anthropic, Google Gemini, Ollama, and more)
 - Outputs Mermaid.js diagrams ready for docs, IDEs, and CI/CD pipelines
 
-**Supported languages:** Python · TypeScript · JavaScript · Java · Go · PHP
+**Supported languages:** Python · TypeScript · JavaScript · Java · Kotlin · Go · PHP
 
 ---
 
 ## Requirements
 
 - **Python 3.12 or 3.13** — other versions are currently not supported.
+- **Linux:** glibc 2.34 or newer (Ubuntu 22.04, Debian 12, RHEL 9 or later), for the Kotlin parser.
 
 ## Installation