codeboarding 0.14.3__tar.gz → 0.14.4__tar.gz

{codeboarding-0.14.3/codeboarding.egg-info → codeboarding-0.14.4}/PKG-INFO

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

{codeboarding-0.14.3 → codeboarding-0.14.4/codeboarding.egg-info}/PKG-INFO

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

{codeboarding-0.14.3 → codeboarding-0.14.4}/codeboarding.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.md
 clustering_ids.py
 constants.py
 github_action.py
+health_main.py
 install.py
 logging_config.py
 main.py

codeboarding-0.14.4/health_main.py

@@ -0,0 +1,152 @@
+"""Standalone entry point for running health checks on a repository.
+
+Runs static analysis and health checks only — no LLM agents or diagram generation.
+Useful for testing health checks in isolation and for CI/CD health gates.
+
+Usage:
+    # Local repository (output written to <repo>/.codeboarding/health/)
+    python health_main.py --local /path/to/repo
+
+    # Remote repository (cloned to cwd/repos/, output to cwd/<repo_name>/.codeboarding/health/)
+    python health_main.py https://github.com/user/repo
+"""
+
+import argparse
+import logging
+from pathlib import Path
+
+from health.runner import run_health_checks
+from health.config import initialize_health_dir, load_health_config
+from logging_config import setup_logging
+from repo_utils import clone_repository, get_repo_name
+from static_analyzer import get_static_analysis
+from utils import CODEBOARDING_DIR_NAME, get_artifact_dir
+from vscode_constants import update_config
+
+logger = logging.getLogger(__name__)
+
+
+def run_health_check_local(
+    repo_path: Path,
+    project_name: str | None = None,
+) -> None:
+    """Run health checks on a local repository.
+
+    Args:
+        repo_path: Path to a local repository
+        project_name: Optional project name (default: repo directory name)
+    """
+    resolved_repo_path = repo_path.resolve()
+    if not resolved_repo_path.is_dir():
+        raise ValueError(f"Repository path does not exist: {resolved_repo_path}")
+
+    resolved_project_name = project_name or resolved_repo_path.name
+    output_dir = resolved_repo_path / CODEBOARDING_DIR_NAME
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    setup_logging(log_dir=output_dir)
+
+    _run_health_checks(resolved_repo_path, resolved_project_name, output_dir)
+
+
+def run_health_check_remote(
+    repo_url: str,
+    project_name: str | None = None,
+) -> None:
+    """Run health checks on a remote repository.
+
+    Args:
+        repo_url: URL of a remote Git repository
+        project_name: Optional project name (default: extracted from URL)
+    """
+    repo_root = Path("repos")
+    repo_name = clone_repository(repo_url, repo_root)
+    resolved_repo_path = repo_root / repo_name
+    resolved_project_name = project_name or get_repo_name(repo_url)
+    output_dir = Path.cwd() / repo_name / CODEBOARDING_DIR_NAME
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    setup_logging(log_dir=output_dir)
+
+    _run_health_checks(resolved_repo_path, resolved_project_name, output_dir)
+
+
+def _run_health_checks(repo_path: Path, project_name: str, output_dir: Path) -> None:
+    """Core health check logic shared by local and remote paths."""
+    logger.info(f"Running health checks on '{project_name}' at {repo_path}")
+
+    static_analysis = get_static_analysis(repo_path, cache_dir=get_artifact_dir(repo_path))
+
+    # Load health check configuration and initialize health config dir
+    health_config_dir = output_dir / "health"
+    initialize_health_dir(health_config_dir)
+    health_config = load_health_config(health_config_dir)
+
+    report = run_health_checks(static_analysis, project_name, config=health_config, repo_path=repo_path)
+
+    if report is None:
+        logger.warning("Health checks skipped: no languages found in static analysis results")
+        return
+
+    report_path = health_config_dir / "health_report.json"
+    report_path.write_text(report.model_dump_json(indent=2, exclude_none=True))
+
+    logger.info(f"Health report written to {report_path} (overall score: {report.overall_score:.3f})")
+
+
+def main():
+    """Main entry point that parses CLI arguments and routes to subcommands."""
+    parser = argparse.ArgumentParser(
+        description="Run static analysis health checks on a repository (local or remote)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Local repository (output written to <repo>/.codeboarding/health/)
+  python health_main.py --local /path/to/repo
+
+  # Remote repository (cloned to cwd/repos/, output to cwd/<repo_name>/.codeboarding/health/)
+  python health_main.py https://github.com/user/repo
+
+        """,
+    )
+    parser.add_argument(
+        "repositories",
+        nargs="*",
+        help="One or more remote Git repository URLs to run health checks on",
+    )
+    parser.add_argument("--local", type=Path, help="Path to a local repository")
+    parser.add_argument(
+        "--project-name",
+        type=str,
+        default=None,
+        help="Name of the project (default: extracted from repo path or URL)",
+    )
+    parser.add_argument(
+        "--binary-location", type=Path, help="Path to the binary directory for language servers and tools"
+    )
+
+    args = parser.parse_args()
+
+    # Validate: must provide either remote repos or --local, not both
+    has_remote = bool(args.repositories)
+    has_local = args.local is not None
+
+    if has_remote == has_local:
+        parser.error("Provide either one or more remote repositories or --local, but not both.")
+
+    # Resolve binary paths for tools (tokei, LSP servers, etc.)
+    if args.binary_location:
+        update_config(args.binary_location)
+
+    try:
+        if has_local:
+            run_health_check_local(args.local, args.project_name)
+        else:
+            for repo_url in args.repositories:
+                run_health_check_remote(repo_url, args.project_name)
+    except ValueError as e:
+        parser.error(str(e))
+
+
+if __name__ == "__main__":
+    main()

{codeboarding-0.14.3 → codeboarding-0.14.4}/pyproject.toml

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

codeboarding-0.14.4/static_analyzer/dotnet_solution.py

@@ -0,0 +1,62 @@
+"""The projects a .NET solution file lists."""
+
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ElementTree
+from pathlib import Path
+
+PROJECT_SUFFIXES = (".csproj", ".fsproj")
+# ``Project("{type guid}") = "Name", "relative\path.csproj", "{project guid}"``
+_SLN_PROJECT_LINE = re.compile(r'^Project\("\{[^}]*\}"\)\s*=\s*"[^"]*",\s*"([^"]+)"', re.MULTILINE)
+
+
+def solution_projects(solution: Path) -> list[Path]:
+    """The project files a ``.sln`` or ``.slnx`` lists, absolute, in listing order.
+
+    Solution folders and files that do not exist are left out; a ``.sln`` names
+    its solution folders with the same ``Project(...)`` syntax as its projects.
+    """
+    if solution.suffix.lower() == ".slnx":
+        listed = [element.get("Path") or "" for element in ElementTree.parse(solution).iter("Project")]
+    else:
+        listed = _SLN_PROJECT_LINE.findall(solution.read_text(encoding="utf-8-sig", errors="replace"))
+    projects: list[Path] = []
+    for raw in listed:
+        path = _project_file(solution.parent, raw)
+        if path is not None and path not in projects:
+            projects.append(path)
+    return projects
+
+
+def analyzer_project_references(projects: list[Path]) -> list[Path]:
+    """The projects referenced with ``OutputItemType="Analyzer"``, absolute, in listing order.
+
+    Why: an analyzer reference resolves to the referenced project's output assembly, so
+    it stays unresolved until that project is built.
+    """
+    analyzers: list[Path] = []
+    for project in projects:
+        try:
+            root = ElementTree.parse(project).getroot()
+        except (ElementTree.ParseError, OSError):
+            continue
+        for reference in root.iter():
+            # Legacy-format projects namespace every tag, so match on the local name.
+            if reference.tag.rpartition("}")[2] != "ProjectReference":
+                continue
+            if (reference.get("OutputItemType") or "").strip().lower() != "analyzer":
+                continue
+            raw = reference.get("Include") or ""
+            if not raw:
+                continue
+            path = _project_file(project.parent, raw)
+            if path is not None and path not in analyzers:
+                analyzers.append(path)
+    return analyzers
+
+
+def _project_file(base: Path, raw: str) -> Path | None:
+    """The project ``raw`` names relative to ``base``, or None if it is not one on disk."""
+    path = (base / raw.replace("\\", "/")).resolve()
+    return path if path.suffix.lower() in PROJECT_SUFFIXES and path.is_file() else None

{codeboarding-0.14.3 → codeboarding-0.14.4}/static_analyzer/engine/adapters/csharp_adapter.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from repo_utils.ignore import RepoIgnoreManager
 from static_analyzer.config import Language, NodeType
 from static_analyzer.dotnet_sdk import DotnetSdkError, resolve_dotnet_sdk, system_dotnet_env
-from static_analyzer.dotnet_solution import solution_projects
+from static_analyzer.dotnet_solution import analyzer_project_references, solution_projects
 from static_analyzer.engine.language_adapter import LanguageAdapter
 from static_analyzer.engine.lsp_client import LSPClient
 from static_analyzer.engine.source_inspector import SourceInspector
@@ -29,6 +29,7 @@ from tool_registry import (
 logger = logging.getLogger(__name__)
 
 _MULTI_TARGET_PROJECT_THRESHOLD = 25
+_DOTNET_TIMEOUT_SECONDS = 600
 _SINGLE_TARGET_FRAMEWORK_TARGETS = r"""<Project>
   <PropertyGroup Condition="'$(CodeBoardingOriginalDirectoryBuildTargetsPath)' == ''">
     <CodeBoardingDirectoryBuildTargetsPath>$([MSBuild]::GetPathOfFileAbove('Directory.Build.targets', '$(MSBuildProjectDirectory)'))</CodeBoardingDirectoryBuildTargetsPath>
@@ -47,6 +48,14 @@ _SINGLE_TARGET_FRAMEWORK_TARGETS = r"""<Project>
     <TargetFrameworks>$([System.String]::Copy('$(CodeBoardingTargetFrameworks)').Trim(';').Split(';')[0])</TargetFrameworks>
     <TargetFrameworks Condition="'$(CodeBoardingPreferredTargetFramework)' != '' and $(CodeBoardingTargetFrameworks.Contains(';$(CodeBoardingPreferredTargetFramework);'))">$(CodeBoardingPreferredTargetFramework)</TargetFrameworks>
   </PropertyGroup>
+  <!-- An analyzer whose assembly is absent cannot run, but Roslyn keeps it as an
+       UnresolvedAnalyzerReference whose checksum throws, failing every
+       textDocument/implementation request in the solution. -->
+  <Target Name="CodeBoardingDropMissingAnalyzers" BeforeTargets="CoreCompile">
+    <ItemGroup>
+      <Analyzer Remove="@(Analyzer)" Condition="!Exists('%(Analyzer.FullPath)')" />
+    </ItemGroup>
+  </Target>
 </Project>
 """
 
@@ -326,14 +335,15 @@ class CSharpAdapter(LanguageAdapter):
         client.wait_for_diagnostics_quiesce(idle_seconds=2.0, max_wait=30.0)
 
     def prepare_project(self, project_root: Path) -> None:
-        """Run ``dotnet restore`` so csharp-ls can resolve framework references.
+        """Run ``dotnet restore``, then build any analyzer projects, so csharp-ls can
+        resolve framework references and analyzer assemblies.
 
         Why: csharp-ls relies on Roslyn / MSBuild to load the project, and
         MSBuild needs ``obj/project.assets.json`` (produced by restore) to
         find the .NET runtime reference assemblies. Without it, csharp-ls
         emits a flood of bogus ``CS0518: Predefined type System.X is not
-        defined`` diagnostics for every file. Restore is idempotent and
-        only writes under ``obj/`` (which we already gitignore).
+        defined`` diagnostics for every file. Restore is idempotent and only writes
+        under ``obj/``; building an analyzer project also writes its ``bin/``.
 
         Restore runs under the MSBuild environment csharp-ls gets, so the two
         evaluate every path the same way and the server finds what restore wrote.
@@ -357,7 +367,12 @@ class CSharpAdapter(LanguageAdapter):
 
         env = os.environ.copy()
         env.update(self.get_lsp_env(project_root))
-        if self._restore(resolution.dotnet_path, target, project_root, env) or target.suffix not in (".sln", ".slnx"):
+        if target.suffix not in (".sln", ".slnx"):
+            self._dotnet("restore", resolution.dotnet_path, target, project_root, env)
+            self._build_analyzers(resolution.dotnet_path, [target], project_root, env)
+            return
+        if self._dotnet("restore", resolution.dotnet_path, target, project_root, env):
+            self._build_analyzers(resolution.dotnet_path, solution_projects(target), project_root, env)
             return
         # A solution restore evaluates every project before writing any assets, so one
         # project it cannot evaluate (a missing workload, a broken import) leaves the
@@ -365,8 +380,11 @@ class CSharpAdapter(LanguageAdapter):
         # or transitive project reference anywhere. Each member on its own only fails
         # for itself.
         projects = solution_projects(target)
-        restored = sum(self._restore(resolution.dotnet_path, project, project_root, env) for project in projects)
+        restored = sum(
+            self._dotnet("restore", resolution.dotnet_path, project, project_root, env) for project in projects
+        )
         logger.info("dotnet restore per project: %d of %d restored", restored, len(projects))
+        self._build_analyzers(resolution.dotnet_path, projects, project_root, env)
 
     def get_lsp_env(self, project_root: Path | None = None) -> dict[str, str]:
         """Return the .NET environment needed by csharp-ls.
@@ -411,29 +429,48 @@ class CSharpAdapter(LanguageAdapter):
                 found.append(sym.get("name", ""))
         return found
 
-    def _restore(self, dotnet_path: str, target: Path, project_root: Path, env: dict[str, str]) -> bool:
+    def _build_analyzers(self, dotnet_path: str, projects: list[Path], project_root: Path, env: dict[str, str]) -> None:
+        """Build the projects referenced as analyzers so Roslyn can resolve them.
+
+        Why: restore does not produce an output assembly, so Roslyn holds an
+        ``UnresolvedAnalyzerReference`` whose checksum throws, failing every
+        ``textDocument/implementation`` request across the whole solution.
+        """
+        analyzers = analyzer_project_references(projects)
+        if not analyzers:
+            return
+        built = sum(self._dotnet("build", dotnet_path, analyzer, project_root, env) for analyzer in analyzers)
+        if built < len(analyzers):
+            # The injected target drops what stays missing, so analysis continues without
+            # the symbols that generator would have produced.
+            logger.warning("dotnet build analyzer projects: only %d of %d built", built, len(analyzers))
+        else:
+            logger.info("dotnet build analyzer projects: %d of %d built", built, len(analyzers))
+
+    def _dotnet(self, verb: str, dotnet_path: str, target: Path, project_root: Path, env: dict[str, str]) -> bool:
         try:
             result = subprocess.run(
-                [dotnet_path, "restore", os.path.relpath(target, project_root), "--nologo", "--verbosity", "minimal"],
+                [dotnet_path, verb, os.path.relpath(target, project_root), "--nologo", "--verbosity", "minimal"],
                 cwd=str(project_root),
                 env=env,
                 capture_output=True,
                 text=True,
-                timeout=600,
+                timeout=_DOTNET_TIMEOUT_SECONDS,
             )
         except subprocess.TimeoutExpired:
-            logger.warning("dotnet restore timed out after 600s for %s", target.name)
+            logger.warning("dotnet %s timed out after %ds for %s", verb, _DOTNET_TIMEOUT_SECONDS, target.name)
             return False
         except OSError as exc:
-            logger.warning("dotnet restore could not be invoked: %s", exc)
+            logger.warning("dotnet %s could not be invoked: %s", verb, exc)
             return False
         if result.returncode != 0:
             logger.warning(
-                "dotnet restore failed for %s (exit %d): %s",
+                "dotnet %s failed for %s (exit %d): %s",
+                verb,
                 target.name,
                 result.returncode,
                 (result.stderr or result.stdout)[-500:],
             )
             return False
-        logger.info("dotnet restore completed for %s", target.name)
+        logger.info("dotnet %s completed for %s", verb, target.name)
         return True

codeboarding-0.14.3/static_analyzer/dotnet_solution.py

@@ -1,29 +0,0 @@
-"""The projects a .NET solution file lists."""
-
-from __future__ import annotations
-
-import re
-import xml.etree.ElementTree as ElementTree
-from pathlib import Path
-
-PROJECT_SUFFIXES = (".csproj", ".fsproj")
-# ``Project("{type guid}") = "Name", "relative\path.csproj", "{project guid}"``
-_SLN_PROJECT_LINE = re.compile(r'^Project\("\{[^}]*\}"\)\s*=\s*"[^"]*",\s*"([^"]+)"', re.MULTILINE)
-
-
-def solution_projects(solution: Path) -> list[Path]:
-    """The project files a ``.sln`` or ``.slnx`` lists, absolute, in listing order.
-
-    Solution folders and files that do not exist are left out; a ``.sln`` names
-    its solution folders with the same ``Project(...)`` syntax as its projects.
-    """
-    if solution.suffix.lower() == ".slnx":
-        listed = [element.get("Path") or "" for element in ElementTree.parse(solution).iter("Project")]
-    else:
-        listed = _SLN_PROJECT_LINE.findall(solution.read_text(encoding="utf-8-sig", errors="replace"))
-    projects: list[Path] = []
-    for raw in listed:
-        path = (solution.parent / raw.replace("\\", "/")).resolve()
-        if path.suffix.lower() in PROJECT_SUFFIXES and path.is_file() and path not in projects:
-            projects.append(path)
-    return projects