codeboarding 0.10.1__tar.gz → 0.10.2__tar.gz

{codeboarding-0.10.1/codeboarding.egg-info → codeboarding-0.10.2}/PKG-INFO

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

{codeboarding-0.10.1 → codeboarding-0.10.2}/agents/cluster_methods_mixin.py

@@ -16,8 +16,11 @@ from agents.agent_responses import (
 from constants import MIN_CLUSTERS_THRESHOLD
 from static_analyzer.analysis_result import StaticAnalysisResults
 from static_analyzer.cluster_helpers import (
+    MAX_LLM_CLUSTERS,
+    enforce_cross_language_budget,
     get_all_cluster_ids,
     get_files_for_cluster_ids,
+    merge_clusters,
 )
 from static_analyzer.cluster_relations import (
     build_component_relations,
@@ -250,7 +253,6 @@ class ClusterMethodsMixin:
             abs_path = os.path.join(self.repo_dir, f) if not os.path.isabs(f) else f
             assigned_file_set.add(abs_path)
 
-        result_parts = []
         cluster_results: dict[str, ClusterResult] = {}
         subgraph_cfgs: dict[str, CallGraph] = {}
 
@@ -266,15 +268,33 @@ class ClusterMethodsMixin:
                 # Calculate clusters for the subgraph
                 sub_cluster_result = sub_cfg.cluster()
 
+                # Merge into super-clusters if too many (same limit as AbstractionAgent)
+                if len(sub_cluster_result.clusters) > MAX_LLM_CLUSTERS:
+                    n_before = len(sub_cluster_result.clusters)
+                    sub_cluster_result = merge_clusters(sub_cluster_result, sub_cfg.to_networkx(), MAX_LLM_CLUSTERS)
+                    logger.info(
+                        f"[DetailsAgent] Subgraph for '{component.name}': "
+                        f"merged {n_before} -> {len(sub_cluster_result.clusters)} super-clusters"
+                    )
+
                 # Expand to method-level if insufficient clusters
                 sub_cluster_result = self._expand_to_method_level_clusters(sub_cfg, sub_cluster_result)
                 cluster_results[lang] = sub_cluster_result
 
-                cluster_str = sub_cfg.to_cluster_string(cluster_result=sub_cluster_result)
-                if cluster_str.strip() and cluster_str not in ("empty", "none", "No clusters found."):
-                    result_parts.append(f"\n## {lang.capitalize()} - Component CFG\n")
-                    result_parts.append(cluster_str)
-                    result_parts.append("\n")
+        # Cross-language: enforce combined budget and unique IDs
+        if len(cluster_results) > 1:
+            cfg_nx = {lang: subgraph_cfgs[lang].to_networkx() for lang in cluster_results}
+            enforce_cross_language_budget(cluster_results, cfg_nx)
+
+        result_parts = []
+        for lang in self.static_analysis.get_languages():
+            if lang not in cluster_results:
+                continue
+            cluster_str = subgraph_cfgs[lang].to_cluster_string(cluster_result=cluster_results[lang])
+            if cluster_str.strip() and cluster_str not in ("empty", "none", "No clusters found."):
+                result_parts.append(f"\n## {lang.capitalize()} - Component CFG\n")
+                result_parts.append(cluster_str)
+                result_parts.append("\n")
 
         result = "".join(result_parts)
 

{codeboarding-0.10.1 → codeboarding-0.10.2}/agents/meta_agent.py

@@ -46,7 +46,6 @@ class MetaAgent(CodeBoardingAgent):
         )
 
         self._meta_cache = MetaCache(repo_dir=repo_dir, ignore_manager=self.ignore_manager)
-        self._cache = self._meta_cache  # Backward-compatible alias for tests/callers.
 
     @trace
     def analyze_project_metadata(self, skip_cache: bool = False) -> MetaAnalysisInsights:

{codeboarding-0.10.1 → codeboarding-0.10.2/codeboarding.egg-info}/PKG-INFO

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

{codeboarding-0.10.1 → codeboarding-0.10.2}/install.py

@@ -14,12 +14,15 @@ import requests
 
 from tool_registry import (
     TOOL_REGISTRY,
+    ProgressCallback,
     ToolKind,
+    _acquire_lock,
     _write_manifest,
     get_servers_dir,
     install_archive_tool,
     install_native_tools,
     install_node_tools,
+    needs_install,
     npm_subprocess_env,
     platform_bin_dir,
     preferred_node_path,
@@ -207,13 +210,13 @@ def get_platform_bin_dir(servers_dir: Path) -> Path:
     return platform_bin_dir(servers_dir)
 
 
-def install_node_servers(target_dir: Path):
+def install_node_servers(target_dir: Path, on_progress: ProgressCallback | None = None):
     """Install Node.js based servers (TypeScript, Pyright) using npm in target_dir."""
     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]
-    install_node_tools(target_dir, node_deps)
+    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"
@@ -369,11 +372,11 @@ def resolve_missing_vcpp(auto_install_vcpp: bool = False) -> bool:
     return False
 
 
-def download_binaries(target_dir: Path, auto_install_vcpp: bool = 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."""
     print("Step: Binary download started")
     native_deps = [d for d in TOOL_REGISTRY if d.kind is ToolKind.NATIVE]
-    install_native_tools(target_dir, native_deps)
+    install_native_tools(target_dir, native_deps, on_progress=on_progress)
 
     # Verify downloaded binaries actually work (catch missing DLL issues on Windows)
     if platform.system() == "Windows":
@@ -411,12 +414,12 @@ def download_binaries(target_dir: Path, auto_install_vcpp: bool = False):
     print("Step: Binary download finished")
 
 
-def download_jdtls(target_dir: Path):
+def download_jdtls(target_dir: Path, on_progress: ProgressCallback | None = None):
     """Download and extract JDTLS from the latest GitHub release."""
     print("Step: JDTLS download started")
     archive_deps = [d for d in TOOL_REGISTRY if d.kind is ToolKind.ARCHIVE]
     for dep in archive_deps:
-        install_archive_tool(target_dir, dep)
+        install_archive_tool(target_dir, dep, on_progress=on_progress)
 
     print("Step: JDTLS download finished")
     return True
@@ -530,27 +533,79 @@ def print_language_support_summary(npm_available: bool, target_dir: Path):
             print(f"    reason: {reason}")
 
 
+def ensure_tools(
+    auto_install_npm: bool = False,
+    auto_install_vcpp: bool = False,
+    on_progress: ProgressCallback | None = None,
+) -> None:
+    """Install tools to ~/.codeboarding/servers/ if needed. No-op if already current.
+
+    Uses a file lock so that concurrent instances (multiple VSCode windows)
+    don't corrupt binaries by downloading simultaneously.
+
+    Args:
+        on_progress: Optional callback invoked as (tool_name, step, total) during downloads.
+    """
+    servers_dir = get_servers_dir()
+    servers_dir.mkdir(parents=True, exist_ok=True)
+    lock_path = servers_dir / ".download.lock"
+
+    with open(lock_path, "w") as lock_fd:
+        _acquire_lock(lock_fd)
+
+        if not needs_install():
+            return
+
+        run_install(
+            target_dir=servers_dir,
+            auto_install_npm=auto_install_npm,
+            auto_install_vcpp=auto_install_vcpp,
+            on_progress=on_progress,
+        )
+        _write_manifest()
+
+
 def run_install(
     target_dir: Path | None = None,
     auto_install_npm: bool = False,
     auto_install_vcpp: bool = False,
+    on_progress: ProgressCallback | None = None,
 ) -> 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.
+
+    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)
 
     ensure_config_template()
 
+    # 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.github_asset_template)
+    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)
     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
+
+    step = 0
+
+    def unified_progress(name: str, _i: int, _t: int) -> None:
+        nonlocal step
+        step += 1
+        if on_progress:
+            on_progress(name, step, total_steps)
+
+    tracker = unified_progress if on_progress else None
+
     if npm_available:
-        install_node_servers(target)
+        install_node_servers(target, on_progress=tracker)
 
-    download_binaries(target, auto_install_vcpp=auto_install_vcpp)
-    download_jdtls(target)
+    download_binaries(target, auto_install_vcpp=auto_install_vcpp, on_progress=tracker)
+    download_jdtls(target, on_progress=tracker)
     install_pre_commit_hooks()
     print_language_support_summary(npm_available, target)
 

{codeboarding-0.10.1 → codeboarding-0.10.2}/main.py

@@ -17,6 +17,8 @@ from diagram_analysis.io_utils import load_full_analysis, save_sub_analysis
 from logging_config import setup_logging
 from monitoring import monitor_execution
 from monitoring.paths import get_monitoring_run_dir
+from install import ensure_tools
+from tool_registry import needs_install
 from output_generators.markdown import generate_markdown_file
 from repo_utils import (
     clone_repository,
@@ -473,8 +475,6 @@ Examples:
     if args.binary_location:
         update_config(args.binary_location)
     else:
-        from tool_registry import ensure_tools, needs_install
-
         if needs_install():
             logger.info("First run: downloading language server binaries to ~/.codeboarding/servers/ ...")
             ensure_tools(auto_install_npm=True, auto_install_vcpp=True)

{codeboarding-0.10.1 → codeboarding-0.10.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codeboarding"
-version = "0.10.1"
+version = "0.10.2"
 description = "Interactive Diagrams for Code"
 readme = "PYPI.md"
 license = "MIT"

{codeboarding-0.10.1 → codeboarding-0.10.2}/static_analyzer/cluster_helpers.py

@@ -88,32 +88,55 @@ def build_all_cluster_results(static_analysis: StaticAnalysisResults) -> dict[st
     # within MAX_LLM_CLUSTERS by proportionally reducing per-language counts,
     # then re-index IDs so they don't overlap across languages.
     if len(cluster_results) > 1:
-        total_clusters = sum(len(cr.clusters) for cr in cluster_results.values())
-        if total_clusters > MAX_LLM_CLUSTERS:
-            # Proportionally allocate budget, minimum 2 per language
-            for lang in list(cluster_results.keys()):
-                cr = cluster_results[lang]
-                lang_count = len(cr.clusters)
-                lang_target = max(2, round(MAX_LLM_CLUSTERS * lang_count / total_clusters))
-                if lang_count > lang_target:
-                    cfg = static_analysis.get_cfg(lang)
-                    logger.info(
-                        f"[SuperCluster] {lang}: reducing {lang_count} -> {lang_target} (cross-language budget)"
-                    )
-                    cluster_results[lang] = merge_clusters(cr, cfg.to_networkx(), lang_target)
-
-        # Re-index so IDs don't overlap across languages
-        offset = 0
-        for lang in sorted(cluster_results.keys()):
-            cr = cluster_results[lang]
-            if offset > 0:
-                cluster_results[lang] = _reindex_cluster_result(cr, offset)
-                logger.info(f"[ReIndex] {lang}: offset IDs by +{offset} (now {offset + 1}-{offset + len(cr.clusters)})")
-            offset += len(cr.clusters)
+        cfg_graphs = {lang: static_analysis.get_cfg(lang).to_networkx() for lang in cluster_results}
+        enforce_cross_language_budget(cluster_results, cfg_graphs)
 
     return cluster_results
 
 
+def enforce_cross_language_budget(
+    cluster_results: dict[str, ClusterResult],
+    cfg_graphs: dict[str, nx.DiGraph],
+    target: int = MAX_LLM_CLUSTERS,
+) -> None:
+    """Enforce a combined cluster budget across languages and re-index IDs.
+
+    Mutates *cluster_results* in place:
+      1. If the combined cluster count exceeds *target*, proportionally reduce
+         each language's count (minimum 2 per language) via ``merge_clusters``.
+      2. Re-index cluster IDs with per-language offsets so they form a unique,
+         non-overlapping namespace (required by downstream code that maps
+         cluster_id -> component in a single dict).
+
+    Args:
+        cluster_results: Language -> ClusterResult mapping (mutated in place).
+        cfg_graphs: Language -> networkx DiGraph for each language (needed by
+            ``merge_clusters`` when reducing).
+        target: Maximum total clusters across all languages.
+    """
+    if len(cluster_results) <= 1:
+        return
+
+    total_clusters = sum(len(cr.clusters) for cr in cluster_results.values())
+    if total_clusters > target:
+        for lang in list(cluster_results.keys()):
+            cr = cluster_results[lang]
+            lang_count = len(cr.clusters)
+            lang_target = max(2, round(target * lang_count / total_clusters))
+            if lang_count > lang_target:
+                logger.info(f"[SuperCluster] {lang}: reducing {lang_count} -> {lang_target} (cross-language budget)")
+                cluster_results[lang] = merge_clusters(cr, cfg_graphs[lang], lang_target)
+
+    # Re-index so IDs don't overlap across languages
+    offset = 0
+    for lang in sorted(cluster_results.keys()):
+        cr = cluster_results[lang]
+        if offset > 0:
+            cluster_results[lang] = reindex_cluster_result(cr, offset)
+            logger.info(f"[ReIndex] {lang}: offset IDs by +{offset} (now {offset + 1}-{offset + len(cr.clusters)})")
+        offset += len(cr.clusters)
+
+
 # ---------------------------------------------------------------------------
 # Meta-graph construction
 # ---------------------------------------------------------------------------
@@ -267,7 +290,7 @@ def _find_nearest_by_file_overlap(
     return best_idx
 
 
-def _reindex_cluster_result(cluster_result: ClusterResult, offset: int) -> ClusterResult:
+def reindex_cluster_result(cluster_result: ClusterResult, offset: int) -> ClusterResult:
     """Re-index all cluster IDs in a ClusterResult by adding an offset.
 
     Args:

{codeboarding-0.10.1 → codeboarding-0.10.2}/tool_registry.py

@@ -18,19 +18,30 @@ import os
 import platform
 import shutil
 import subprocess
+import sys
 import tarfile
+import time
+from collections.abc import Callable
 from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import StrEnum
 from pathlib import Path
 from typing import Any, cast
 
+if sys.platform == "win32":
+    import msvcrt
+else:
+    import fcntl
+
 import requests
 
 from vscode_constants import VSCODE_CONFIG, find_runnable
 
 logger = logging.getLogger(__name__)
 
+# Callback type for reporting download progress: (tool_name, current_step, total_steps)
+ProgressCallback = Callable[[str, int, int], None]
+
 GITHUB_REPO = "CodeBoarding/CodeBoarding"
 
 _PLATFORM_SUFFIX = {
@@ -292,18 +303,31 @@ def needs_install() -> bool:
     return not has_required_tools(get_servers_dir())
 
 
-def ensure_tools(auto_install_npm: bool = False, auto_install_vcpp: bool = False) -> None:
-    """Install tools to ~/.codeboarding/servers/ if needed. No-op if already current."""
-    if not needs_install():
-        return
-    from install import run_install  # deferred to avoid circular import at module level
-
-    run_install(
-        target_dir=get_servers_dir(),
-        auto_install_npm=auto_install_npm,
-        auto_install_vcpp=auto_install_vcpp,
-    )
-    _write_manifest()
+def _acquire_lock(lock_fd: Any) -> None:
+    """Acquire an exclusive file lock, logging if we have to wait."""
+    if sys.platform == "win32":
+        # msvcrt.LK_LOCK only retries for ~10 s which is too short for tool
+        # downloads.  Poll with LK_NBLCK every 2 s instead — no hard timeout.
+        try:
+            msvcrt.locking(lock_fd.fileno(), msvcrt.LK_NBLCK, 1)
+        except OSError:
+            logger.info("Another instance is downloading tools, waiting...")
+            print("Waiting for another instance to finish downloading tools...", flush=True, file=sys.stderr)
+            while True:
+                time.sleep(2)
+                try:
+                    msvcrt.locking(lock_fd.fileno(), msvcrt.LK_NBLCK, 1)
+                    break
+                except OSError:
+                    continue
+    else:
+        # fcntl.LOCK_EX blocks indefinitely — exactly what we want.
+        try:
+            fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            logger.info("Another instance is downloading tools, waiting...")
+            print("Waiting for another instance to finish downloading tools...", flush=True, file=sys.stderr)
+            fcntl.flock(lock_fd, fcntl.LOCK_EX)
 
 
 def build_config() -> dict[str, Any]:
@@ -461,19 +485,36 @@ def get_latest_release_tag() -> str:
 
 
 def download_asset(tag: str, asset_name: str, destination: Path) -> bool:
-    """Download a GitHub release asset to destination. Returns True on success."""
+    """Download a GitHub release asset to destination. Returns True on success.
+
+    Writes to a temp file first, then atomically renames to prevent
+    corrupt binaries if the download is interrupted.
+    """
     destination.parent.mkdir(parents=True, exist_ok=True)
+    temp_dest = destination.with_suffix(destination.suffix + ".download")
     url = f"https://github.com/{GITHUB_REPO}/releases/download/{tag}/{asset_name}"
-    response = requests.get(url, stream=True, timeout=300, allow_redirects=True)
-    response.raise_for_status()
-    with open(destination, "wb") as f:
-        for chunk in response.iter_content(chunk_size=32768):
-            if chunk:
-                f.write(chunk)
-    return destination.exists() and destination.stat().st_size > 0
+    try:
+        response = requests.get(url, stream=True, timeout=300, allow_redirects=True)
+        response.raise_for_status()
+        with open(temp_dest, "wb") as f:
+            for chunk in response.iter_content(chunk_size=32768):
+                if chunk:
+                    f.write(chunk)
+        if temp_dest.stat().st_size > 0:
+            os.replace(temp_dest, destination)
+            return True
+        temp_dest.unlink(missing_ok=True)
+        return False
+    except Exception:
+        temp_dest.unlink(missing_ok=True)
+        raise
 
 
-def install_native_tools(target_dir: Path, deps: list[ToolDependency]) -> None:
+def install_native_tools(
+    target_dir: Path,
+    deps: list[ToolDependency],
+    on_progress: ProgressCallback | None = None,
+) -> None:
     """Download native binaries from GitHub releases."""
     system = platform.system()
     suffix = _PLATFORM_SUFFIX.get(system)
@@ -491,8 +532,10 @@ def install_native_tools(target_dir: Path, deps: list[ToolDependency]) -> None:
         logger.exception("Could not determine latest release")
         return
 
-    for dep in deps:
-        assert dep.github_asset_template, f"{dep.key}: github_asset_template required for native tools"
+    downloadable = [d for d in deps if d.github_asset_template]
+    for i, dep in enumerate(downloadable, 1):
+        if on_progress:
+            on_progress(dep.binary_name, i, len(downloadable))
         binary_path = bin_dir / f"{dep.binary_name}{exe_suffix()}"
         if binary_path.exists():
             logger.info("  %s: already installed, skipping", dep.binary_name)
@@ -511,7 +554,11 @@ def install_native_tools(target_dir: Path, deps: list[ToolDependency]) -> None:
             binary_path.unlink(missing_ok=True)
 
 
-def install_node_tools(target_dir: Path, deps: list[ToolDependency]) -> None:
+def install_node_tools(
+    target_dir: Path,
+    deps: list[ToolDependency],
+    on_progress: ProgressCallback | None = None,
+) -> None:
     """Install Node.js tools via npm."""
     npm_command = preferred_npm_command(target_dir)
     if not npm_command:
@@ -527,6 +574,8 @@ def install_node_tools(target_dir: Path, deps: list[ToolDependency]) -> None:
         return
 
     env = npm_subprocess_env(target_dir)
+    if on_progress:
+        on_progress("npm packages", 1, 1)
     logger.info("Installing Node.js packages: %s", all_packages)
     try:
         if not (target_dir / "package.json").exists():
@@ -548,11 +597,18 @@ def install_node_tools(target_dir: Path, deps: list[ToolDependency]) -> None:
         logger.exception("Node.js package installation failed")
 
 
-def install_archive_tool(target_dir: Path, dep: ToolDependency) -> None:
+def install_archive_tool(
+    target_dir: Path,
+    dep: ToolDependency,
+    on_progress: ProgressCallback | None = None,
+) -> None:
     """Download and extract an archive tool."""
     assert dep.archive_asset, f"{dep.key}: archive_asset required for archive tools"
     assert dep.archive_subdir, f"{dep.key}: archive_subdir required for archive tools"
 
+    if on_progress:
+        on_progress(dep.key, 1, 1)
+
     extract_dir = target_dir / "bin" / dep.archive_subdir
     if extract_dir.exists() and (extract_dir / "plugins").is_dir():
         logger.info("%s already installed", dep.key)
@@ -575,3 +631,5 @@ def install_archive_tool(target_dir: Path, dep: ToolDependency) -> None:
     except Exception:
         logger.exception("%s installation failed", dep.key)
         archive_path.unlink(missing_ok=True)
+        logger.exception("%s installation failed", dep.key)
+        archive_path.unlink(missing_ok=True)