codeboarding 0.14.0__tar.gz → 0.14.1__tar.gz

{codeboarding-0.14.0/codeboarding.egg-info → codeboarding-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.14.0
+Version: 0.14.1
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT
@@ -140,7 +140,7 @@ generated `.codeboarding/analysis.json` — it is parsed in your browser, nothin
 ```python
 import json
 from pathlib import Path
-from diagram_analysis import DiagramGenerator, configure_models
+from diagram_analysis import DiagramGenerator, RunContext, configure_models
 from diagram_analysis.analysis_json import parse_unified_analysis
 
 # Pass the key programmatically — shell env vars always take precedence if already set.
@@ -153,14 +153,17 @@ output_dir = repo_path / ".codeboarding"
 output_dir.mkdir(parents=True, exist_ok=True)
 
 # Generate the architectural diagram
+context = RunContext.resolve("my-project")
 generator = DiagramGenerator(
     repo_location=repo_path,
     temp_folder=output_dir,
     repo_name="my-project",
     output_dir=output_dir,
-    depth_level=3,  # safety-valve cap; a component that outgrows the leaf ceiling is flagged expandable and can be expanded on demand
+    depth_cap=3,  # Maximum hierarchy depth for automatic expansion, not a target.
+    run_id=context.run_id,
+    log_path=context.log_path,
 )
-[analysis_path] = generator.generate_analysis()
+analysis_path = generator.generate_analysis()
 
 # Read and inspect the results
 with open(analysis_path) as f:
@@ -221,7 +224,7 @@ codeboarding-render PATH/analysis.json --format FORMAT # render an existing anal
 |---|---|
 | `--local PATH` | Analyze a local repository (output: `PATH/.codeboarding/`) |
 | `--render {md,html,mdx,rst}` | Render overview and component files from the local `analysis.json` for full, incremental, or partial commands |
-| `--depth-level INT` | Safety-valve depth cap (default: 3) on how deep auto-expansion goes; a component that outgrows the leaf ceiling is flagged expandable regardless, and can be expanded on demand |
+| `--depth-cap INT` | Maximum allowed hierarchy depth for automatic expansion (default: 3), not a target. Components can still be expanded on demand. Configures `metadata.depth_cap`, not `metadata.depth_level` (the depth actually reached). No input alias is accepted. |
 | `--force` | (full only) Force full reanalysis, skip cached static analysis |
 | `--base-ref REF` / `--target-ref REF` | (incremental only) Git refs to diff |
 | `--component-id ID` | (partial only) ID of the component to update |

{codeboarding-0.14.0 → codeboarding-0.14.1}/PYPI.md

@@ -67,7 +67,7 @@ generated `.codeboarding/analysis.json` — it is parsed in your browser, nothin
 ```python
 import json
 from pathlib import Path
-from diagram_analysis import DiagramGenerator, configure_models
+from diagram_analysis import DiagramGenerator, RunContext, configure_models
 from diagram_analysis.analysis_json import parse_unified_analysis
 
 # Pass the key programmatically — shell env vars always take precedence if already set.
@@ -80,14 +80,17 @@ output_dir = repo_path / ".codeboarding"
 output_dir.mkdir(parents=True, exist_ok=True)
 
 # Generate the architectural diagram
+context = RunContext.resolve("my-project")
 generator = DiagramGenerator(
     repo_location=repo_path,
     temp_folder=output_dir,
     repo_name="my-project",
     output_dir=output_dir,
-    depth_level=3,  # safety-valve cap; a component that outgrows the leaf ceiling is flagged expandable and can be expanded on demand
+    depth_cap=3,  # Maximum hierarchy depth for automatic expansion, not a target.
+    run_id=context.run_id,
+    log_path=context.log_path,
 )
-[analysis_path] = generator.generate_analysis()
+analysis_path = generator.generate_analysis()
 
 # Read and inspect the results
 with open(analysis_path) as f:
@@ -148,7 +151,7 @@ codeboarding-render PATH/analysis.json --format FORMAT # render an existing anal
 |---|---|
 | `--local PATH` | Analyze a local repository (output: `PATH/.codeboarding/`) |
 | `--render {md,html,mdx,rst}` | Render overview and component files from the local `analysis.json` for full, incremental, or partial commands |
-| `--depth-level INT` | Safety-valve depth cap (default: 3) on how deep auto-expansion goes; a component that outgrows the leaf ceiling is flagged expandable regardless, and can be expanded on demand |
+| `--depth-cap INT` | Maximum allowed hierarchy depth for automatic expansion (default: 3), not a target. Components can still be expanded on demand. Configures `metadata.depth_cap`, not `metadata.depth_level` (the depth actually reached). No input alias is accepted. |
 | `--force` | (full only) Force full reanalysis, skip cached static analysis |
 | `--base-ref REF` / `--target-ref REF` | (incremental only) Git refs to diff |
 | `--component-id ID` | (partial only) ID of the component to update |

{codeboarding-0.14.0 → codeboarding-0.14.1}/README.md

@@ -155,8 +155,8 @@ python main.py 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-level is a safety-valve cap, default 3)
-python main.py full --local ./my-project --depth-level 5
+# 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
 
 # Re-analyze only changed parts when possible
 python main.py incremental --local ./my-project
@@ -168,6 +168,20 @@ python main.py partial --local ./my-project --component-id "1.2"
 python main.py full https://github.com/pytorch/pytorch
 ```
 
+`--depth-cap` configures `metadata.depth_cap`; `metadata.depth_level` records the
+depth actually reached. The cap is a maximum, not a target depth. `--depth-level`
+is rejected; there is no compatibility alias.
+
+Python callers must use `run_full(..., depth_cap=...)`,
+`build_generator(..., depth_cap=...)`, and `DiagramGenerator(..., depth_cap=...)`.
+The generator attribute is `depth_cap` and the exported default is
+`diagram_analysis.DEFAULT_DEPTH_CAP` (3). The GitHub helper uses `DIAGRAM_DEPTH_CAP`
+and rejects `DIAGRAM_DEPTH_LEVEL`. Telemetry reports configured `depth_cap`, not
+`depth_level`. Readers of analysis results must keep reading `metadata.depth_level`
+for the actual depth. Existing baseline loading behavior is unchanged: prefer
+`metadata.depth_cap`, fall back to legacy `metadata.depth_level`, then use
+`DEFAULT_DEPTH_CAP` if neither exists. This metadata fallback is not a CLI alias.
+
 > **Incremental needs a baseline.** `incremental` diffs the working tree against the previous
 > analysis in `.codeboarding/` (`analysis.json` + `fingerprint.json`). That baseline can live
 > purely locally — a prior `full`/`incremental` run in the same output dir is enough. Commit

{codeboarding-0.14.0 → codeboarding-0.14.1/codeboarding.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.14.0
+Version: 0.14.1
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT
@@ -140,7 +140,7 @@ generated `.codeboarding/analysis.json` — it is parsed in your browser, nothin
 ```python
 import json
 from pathlib import Path
-from diagram_analysis import DiagramGenerator, configure_models
+from diagram_analysis import DiagramGenerator, RunContext, configure_models
 from diagram_analysis.analysis_json import parse_unified_analysis
 
 # Pass the key programmatically — shell env vars always take precedence if already set.
@@ -153,14 +153,17 @@ output_dir = repo_path / ".codeboarding"
 output_dir.mkdir(parents=True, exist_ok=True)
 
 # Generate the architectural diagram
+context = RunContext.resolve("my-project")
 generator = DiagramGenerator(
     repo_location=repo_path,
     temp_folder=output_dir,
     repo_name="my-project",
     output_dir=output_dir,
-    depth_level=3,  # safety-valve cap; a component that outgrows the leaf ceiling is flagged expandable and can be expanded on demand
+    depth_cap=3,  # Maximum hierarchy depth for automatic expansion, not a target.
+    run_id=context.run_id,
+    log_path=context.log_path,
 )
-[analysis_path] = generator.generate_analysis()
+analysis_path = generator.generate_analysis()
 
 # Read and inspect the results
 with open(analysis_path) as f:
@@ -221,7 +224,7 @@ codeboarding-render PATH/analysis.json --format FORMAT # render an existing anal
 |---|---|
 | `--local PATH` | Analyze a local repository (output: `PATH/.codeboarding/`) |
 | `--render {md,html,mdx,rst}` | Render overview and component files from the local `analysis.json` for full, incremental, or partial commands |
-| `--depth-level INT` | Safety-valve depth cap (default: 3) on how deep auto-expansion goes; a component that outgrows the leaf ceiling is flagged expandable regardless, and can be expanded on demand |
+| `--depth-cap INT` | Maximum allowed hierarchy depth for automatic expansion (default: 3), not a target. Components can still be expanded on demand. Configures `metadata.depth_cap`, not `metadata.depth_level` (the depth actually reached). No input alias is accepted. |
 | `--force` | (full only) Force full reanalysis, skip cached static analysis |
 | `--base-ref REF` / `--target-ref REF` | (incremental only) Git refs to diff |
 | `--component-id ID` | (partial only) ID of the component to update |

{codeboarding-0.14.0 → codeboarding-0.14.1}/codeboarding_cli/commands/full_analysis.py

@@ -11,7 +11,7 @@ from codeboarding_workflows.analysis import run_full
 from codeboarding_workflows.orchestration import run_analysis_pipeline
 from codeboarding_workflows.sources import SourceContext, local_source, remote_source
 from constants import CLI_ROOT_DOCUMENT_NAME
-from diagram_analysis import DEFAULT_DEPTH_LEVEL, RunContext, RunPaths
+from diagram_analysis import DEFAULT_DEPTH_CAP, RunContext, RunPaths
 from monitoring import monitor_execution
 from monitoring.paths import get_monitoring_run_dir
 from output_generators.rendering import render_docs
@@ -45,13 +45,16 @@ def add_arguments(subparsers: argparse._SubParsersAction, parents: list[argparse
         help="Force full reanalysis, skipping cached static analysis",
     )
     parser.add_argument(
-        "--depth-level",
+        "--depth-cap",
+        dest="depth_cap",
         type=int,
-        default=DEFAULT_DEPTH_LEVEL,
+        default=DEFAULT_DEPTH_CAP,
         help=(
-            "Safety-valve ceiling on how deep components auto-expand (default: "
-            f"{DEFAULT_DEPTH_LEVEL}). A component that outgrows the leaf ceiling is flagged expandable "
-            "regardless and can be expanded on demand; raise this only to auto-expand deeper up front."
+            "Maximum allowed hierarchy depth for automatic expansion (default: "
+            f"{DEFAULT_DEPTH_CAP}). A component that outgrows the leaf ceiling is flagged expandable "
+            "regardless and can be expanded on demand; raise this only to auto-expand deeper up front. "
+            "This configures metadata.depth_cap, "
+            "not metadata.depth_level (the depth actually reached)."
         ),
     )
 
@@ -103,7 +106,7 @@ def _run_local(args: argparse.Namespace) -> None:
         run_full(
             RunPaths(repo_path=src.repo_path, output_dir=src.artifact_dir, project_name=src.project_name),
             run_context,
-            depth_level=args.depth_level,
+            depth_cap=args.depth_cap,
             monitoring_enabled=should_monitor,
             force_full=args.force,
             source_sha=get_current_commit(src.repo_path),
@@ -152,7 +155,7 @@ def _run_remote(args: argparse.Namespace) -> None:
             _process_one_remote(
                 repo_url=repo_url,
                 workspace_root=workspace_root,
-                depth_level=args.depth_level,
+                depth_cap=args.depth_cap,
                 upload=args.upload,
                 should_monitor=should_monitor,
             )
@@ -166,7 +169,7 @@ def _run_remote(args: argparse.Namespace) -> None:
 def _process_one_remote(
     repo_url: str,
     workspace_root: Path,
-    depth_level: int,
+    depth_cap: int,
     upload: bool,
     should_monitor: bool,
 ) -> None:
@@ -185,7 +188,7 @@ def _process_one_remote(
             analysis_path = run_full(
                 RunPaths(repo_path=src.repo_path, output_dir=src.artifact_dir, project_name=src.project_name),
                 run_context,
-                depth_level=depth_level,
+                depth_cap=depth_cap,
                 monitoring_enabled=should_monitor,
                 source_sha=get_current_commit(src.repo_path),
             )

{codeboarding-0.14.0 → codeboarding-0.14.1}/codeboarding_workflows/analysis.py

@@ -17,7 +17,7 @@ from agents.content_hash import compute_source_tree_hash
 from agents.scope_ids import ROOT_SCOPE_ID
 from diagram_analysis import DiagramGenerator
 from diagram_analysis.io_utils import load_analysis_metadata, load_expandable_component_ids, load_full_analysis
-from diagram_analysis.run_context import DEFAULT_DEPTH_LEVEL, RunContext, RunPaths
+from diagram_analysis.run_context import DEFAULT_DEPTH_CAP, RunContext, RunPaths
 from repo_utils.change_detector import ChangeSet
 from repo_utils.fingerprint_diff import BaselineUnavailableError, detect_changes_from_fingerprint
 from telemetry.events import track_analysis
@@ -30,7 +30,7 @@ __all__ = ["BaselineUnavailableError", "run_full", "run_partial", "run_increment
 def build_generator(
     run_paths: RunPaths,
     run_context: RunContext,
-    depth_level: int,
+    depth_cap: int,
     monitoring_enabled: bool = False,
     static_analyzer=None,
     changes=None,
@@ -40,7 +40,7 @@ def build_generator(
         temp_folder=run_paths.output_dir,
         repo_name=run_paths.project_name,
         output_dir=run_paths.output_dir,
-        depth_level=depth_level,
+        depth_cap=depth_cap,
         run_id=run_context.run_id,
         log_path=run_context.log_path,
         monitoring_enabled=monitoring_enabled,
@@ -52,7 +52,7 @@ def build_generator(
 def run_full(
     run_paths: RunPaths,
     run_context: RunContext,
-    depth_level: int = DEFAULT_DEPTH_LEVEL,
+    depth_cap: int = DEFAULT_DEPTH_CAP,
     monitoring_enabled: bool = False,
     force_full: bool = False,
     static_analyzer=None,
@@ -63,7 +63,7 @@ def run_full(
     generator = build_generator(
         run_paths,
         run_context,
-        depth_level=depth_level,
+        depth_cap=depth_cap,
         monitoring_enabled=monitoring_enabled,
         static_analyzer=static_analyzer,
     )
@@ -87,8 +87,7 @@ def run_partial(
         f"Running PARTIAL analysis workflow for project '{run_paths.project_name}', component '{component_id}'."
     )
 
-    # Depth is the baseline's configured cap (metadata.depth_cap), with a
-    # legacy depth_level fallback — not the realized depth.
+    # Prefer the configured cap; retain depth_level for legacy baselines.
     metadata = load_analysis_metadata(run_paths.output_dir)
     if metadata is None:
         raise BaselineUnavailableError(
@@ -107,7 +106,7 @@ def run_partial(
             "Partial analysis requires an up-to-date source baseline. Run incremental analysis before expanding a component."
         )
 
-    depth_level = int(metadata.get("depth_cap", metadata.get("depth_level", DEFAULT_DEPTH_LEVEL)))
+    depth_cap = int(metadata.get("depth_cap", metadata.get("depth_level", DEFAULT_DEPTH_CAP)))
     full_analysis = load_full_analysis(run_paths.output_dir)
     if full_analysis is None:
         # Metadata was present but the unified read failed — treat as a
@@ -139,11 +138,11 @@ def run_partial(
         logger.error(f"Component with ID '{component_id}' not found in analysis")
         return
 
-    generator = build_generator(run_paths, run_context, depth_level=depth_level, changes=ChangeSet(files=[]))
+    generator = build_generator(run_paths, run_context, depth_cap=depth_cap, changes=ChangeSet(files=[]))
     generator.source_sha = current_source_hash
     # A component at the persisted cap needs one additional level prepared for expansion.
     generator.prepare_analysis(
-        hierarchy_depth=depth_level + 1,
+        hierarchy_depth=depth_cap + 1,
         target_component=component_to_analyze,
         persisted_scopes={ROOT_SCOPE_ID: root_analysis, **sub_analyses},
     )
@@ -189,19 +188,13 @@ def run_incremental(
     should surface a "run full analysis" prompt rather than silently degrading to
     an unscoped run.
     """
-    # Depth comes from the existing analysis.json's configured cap
-    # (metadata.depth_cap, falling back to depth_level for legacy baselines
-    # that predate it) — not the realized depth_level, so a run that stopped
-    # short of its cap doesn't leave incremental permanently capped shallower
-    # than what was actually configured. Fail fast on cold-start:
-    # ``_generate_subcomponents`` requires the prior depth to re-detail
-    # changed components.
+    # Prefer the configured cap; retain depth_level for legacy baselines.
     metadata = load_analysis_metadata(run_paths.output_dir)
     if metadata is None:
         raise BaselineUnavailableError(
             f"No baseline analysis.json found in '{run_paths.output_dir}'. Run a full analysis first."
         )
-    depth_level = int(metadata.get("depth_cap", metadata.get("depth_level", DEFAULT_DEPTH_LEVEL)))
+    depth_cap = int(metadata.get("depth_cap", metadata.get("depth_level", DEFAULT_DEPTH_CAP)))
 
     changes = detect_changes_from_fingerprint(run_paths.repo_path, run_paths.output_dir)
     logger.info(
@@ -212,7 +205,7 @@ def run_incremental(
     generator = build_generator(
         run_paths,
         run_context,
-        depth_level=depth_level,
+        depth_cap=depth_cap,
         monitoring_enabled=monitoring_enabled,
         static_analyzer=static_analyzer,
         changes=changes,

{codeboarding-0.14.0 → codeboarding-0.14.1}/diagram_analysis/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__all__ = ["DiagramGenerator", "RunContext", "RunPaths", "DEFAULT_DEPTH_LEVEL", "configure_models"]
+__all__ = ["DiagramGenerator", "RunContext", "RunPaths", "DEFAULT_DEPTH_CAP", "configure_models"]
 
 
 def __getattr__(name: str):
@@ -19,10 +19,10 @@ def __getattr__(name: str):
         from .run_context import RunPaths
 
         return RunPaths
-    if name == "DEFAULT_DEPTH_LEVEL":
-        from .run_context import DEFAULT_DEPTH_LEVEL
+    if name == "DEFAULT_DEPTH_CAP":
+        from .run_context import DEFAULT_DEPTH_CAP
 
-        return DEFAULT_DEPTH_LEVEL
+        return DEFAULT_DEPTH_CAP
     if name == "configure_models":
         from agents.llm_config import configure_models
 

{codeboarding-0.14.0 → codeboarding-0.14.1}/diagram_analysis/analysis_json.py

@@ -99,7 +99,7 @@ class AnalysisMetadata(BaseModel):
     repo_name: str = Field(description="Name of the analyzed repository.")
     depth_level: int = Field(description="Maximum depth level actually reached by this analysis.")
     depth_cap: int = Field(
-        description="Safety-valve depth ceiling the run was configured with (see --depth-level); "
+        description="Safety-valve depth ceiling the run was configured with (see --depth-cap); "
         "may exceed depth_level when separability stopped expansion before the cap. "
         "The value future incremental/partial runs reuse as their own cap."
     )

{codeboarding-0.14.0 → codeboarding-0.14.1}/diagram_analysis/diagram_generator.py

@@ -555,7 +555,7 @@ class DiagramGenerator:
         temp_folder: Path,
         repo_name: str,
         output_dir: Path,
-        depth_level: int,
+        depth_cap: int,
         run_id: str,
         log_path: str,
         project_name: str | None = None,
@@ -567,7 +567,7 @@ class DiagramGenerator:
         self.temp_folder = temp_folder
         self.repo_name = repo_name
         self.output_dir = output_dir
-        self.depth_level = depth_level
+        self.depth_cap = depth_cap
         self.project_name = project_name
         self.run_id = run_id
         self.log_path = log_path
@@ -664,7 +664,7 @@ class DiagramGenerator:
             static_analysis = self._get_static_with_new_analyzer()
 
         self.static_analysis = static_analysis
-        depth = hierarchy_depth if hierarchy_depth is not None else self.depth_level
+        depth = hierarchy_depth if hierarchy_depth is not None else self.depth_cap
         if incremental:
             root_analysis = persisted_scopes.get(ROOT_SCOPE_ID)
             if root_analysis is None:
@@ -1295,7 +1295,7 @@ class DiagramGenerator:
                 logger.debug("Submitted component='%s' at level=%d", comp.name, lvl)
 
             # 1. Initial Seeding
-            for component, level in _component_expansion_seeds(root_components, self.depth_level):
+            for component, level in _component_expansion_seeds(root_components, self.depth_cap):
                 submit_component(component, level)
 
             logger.info(
@@ -1340,11 +1340,11 @@ class DiagramGenerator:
                             source_tree_hash=self._source_tree_hash(),
                             expandable_component_ids=expandable_ids,
                             sub_expandable_ids=sub_expandable_ids,
-                            depth_cap=self.depth_level,
+                            depth_cap=self.depth_cap,
                             tree_spec=self._tree_spec_dict(),
                         )
 
-                    if new_components and level + 1 < self.depth_level:
+                    if new_components and level + 1 < self.depth_cap:
                         for child in new_components:
                             submit_component(child, level + 1)
 
@@ -1524,7 +1524,7 @@ class DiagramGenerator:
             source_tree_hash=source_tree_hash,
             expandable_component_ids=expandable_component_ids,
             sub_expandable_ids=sub_expandable_ids,
-            depth_cap=self.depth_level,
+            depth_cap=self.depth_cap,
             tree_spec=self._tree_spec_dict(),
         ).resolve()
         if persist_side_artifacts:
@@ -1633,7 +1633,7 @@ class DiagramGenerator:
             self._incremental_preparation = self._prepare_incremental_clustering(
                 root_analysis,
                 sub_analyses,
-                self.depth_level,
+                self.depth_cap,
             )
             if self.incremental_updater is None:
                 self.agent_init()
@@ -1698,7 +1698,7 @@ class DiagramGenerator:
                 component
                 for component in created_components
                 if component.component_id in hierarchy.preclustered_scopes
-                and _component_depth(component.component_id) < self.depth_level
+                and _component_depth(component.component_id) < self.depth_cap
             ]
             generated_scope_ids: frozenset[str] = frozenset()
             if new_components:

{codeboarding-0.14.0 → codeboarding-0.14.1}/diagram_analysis/io_utils.py

@@ -30,7 +30,7 @@ from diagram_analysis.analysis_json import (
     build_unified_analysis_json,
     parse_unified_analysis,
 )
-from diagram_analysis.run_context import DEFAULT_DEPTH_LEVEL
+from diagram_analysis.run_context import DEFAULT_DEPTH_CAP
 from utils import ANALYSIS_FILENAME, FINGERPRINT_FILENAME
 
 logger = logging.getLogger(__name__)
@@ -183,19 +183,15 @@ class _AnalysisFileStore:
                 if depth_cap is None:
                     depth_cap = metadata.get("depth_cap")
                     if depth_cap is None:
-                        # Legacy baselines predate depth_cap and only recorded depth_level,
-                        # which is the depth the run *realized* — often short of the cap it
-                        # was configured with. Reusing it as a cap can pin the tree shallower
-                        # than its owner asked for, so say so rather than silently narrowing.
                         depth_cap = metadata.get("depth_level")
                         if depth_cap is not None:
                             logger.warning(
                                 "Baseline has no depth_cap; using its realized depth_level=%s as the cap. "
-                                "Run a full analysis with --depth-level to widen it.",
+                                "Run a full analysis with --depth-cap to widen it.",
                                 depth_cap,
                             )
         if depth_cap is None:
-            depth_cap = DEFAULT_DEPTH_LEVEL
+            depth_cap = DEFAULT_DEPTH_CAP
 
         # Convert sub_analyses dict to the format expected by build_unified_analysis_json
         sub_analyses_tuples: dict[str, tuple[AnalysisInsights, list[Component]]] | None = None

{codeboarding-0.14.0 → codeboarding-0.14.1}/diagram_analysis/run_context.py

@@ -4,12 +4,12 @@ from pathlib import Path
 from monitoring.paths import generate_log_path
 from utils import generate_run_id
 
-# Safety-valve depth cap, not a target — see --depth-level help / README for why.
+# Safety-valve depth cap, not a target — see --depth-cap help / README for why.
 # A component that outgrows the leaf ceiling is flagged expandable at whatever depth
 # the run stops, so this cap bounds how much gets expanded up front, not whether a
 # large component *can* be expanded (on demand, via the partial-analysis API). Raise
 # it to auto-expand deeper.
-DEFAULT_DEPTH_LEVEL = 3
+DEFAULT_DEPTH_CAP = 3
 
 
 @dataclass(frozen=True, slots=True)

{codeboarding-0.14.0 → codeboarding-0.14.1}/github_action.py

@@ -4,7 +4,7 @@ import shutil
 from pathlib import Path
 
 from codeboarding_workflows.analysis import run_incremental_workflow
-from diagram_analysis import DEFAULT_DEPTH_LEVEL, DiagramGenerator, RunContext
+from diagram_analysis import DEFAULT_DEPTH_CAP, DiagramGenerator, RunContext
 from diagram_analysis.io_utils import load_analysis_metadata
 from output_generators.rendering import render_docs
 from repo_utils import checkout_repo, clone_repository
@@ -85,15 +85,17 @@ def _seed_existing_analysis(existing_analysis_dir: Path, temp_repo_folder: Path)
             logger.info(f"Seeded existing {filename} for incremental analysis")
 
 
-def _resolve_depth_level(temp_repo_folder: Path) -> int:
+def _resolve_depth_cap(temp_repo_folder: Path) -> int:
     """Depth cap: explicit env var, else the seeded baseline's own depth_cap, else the default."""
-    env_depth = os.getenv("DIAGRAM_DEPTH_LEVEL")
+    if "DIAGRAM_DEPTH_LEVEL" in os.environ:
+        raise ValueError("DIAGRAM_DEPTH_LEVEL is no longer supported; use DIAGRAM_DEPTH_CAP")
+    env_depth = os.getenv("DIAGRAM_DEPTH_CAP")
     if env_depth is not None:
         return int(env_depth)
     metadata = load_analysis_metadata(temp_repo_folder)
     if metadata is not None:
-        return int(metadata.get("depth_cap", metadata.get("depth_level", DEFAULT_DEPTH_LEVEL)))
-    return DEFAULT_DEPTH_LEVEL
+        return int(metadata.get("depth_cap", DEFAULT_DEPTH_CAP))
+    return DEFAULT_DEPTH_CAP
 
 
 def generate_analysis(
@@ -121,7 +123,7 @@ def generate_analysis(
         temp_folder=temp_repo_folder,
         repo_name=repo_name,
         output_dir=temp_repo_folder,
-        depth_level=_resolve_depth_level(temp_repo_folder),
+        depth_cap=_resolve_depth_cap(temp_repo_folder),
         run_id=run_context.run_id,
         log_path=run_context.log_path,
     )

{codeboarding-0.14.0 → codeboarding-0.14.1}/main.py

@@ -46,7 +46,7 @@ Examples:
 
   # Local full analysis with a higher depth ceiling (rarely needed — expansion
   # is driven by structural separability, this only raises the safety-valve cap)
-  codeboarding --local /path/to/repo --depth-level 5
+  codeboarding --local /path/to/repo --depth-cap 5
 
   # Incremental update on a local repository (explicit subcommand required)
   codeboarding incremental --local /path/to/repo

{codeboarding-0.14.0 → codeboarding-0.14.1}/pyproject.toml

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

{codeboarding-0.14.0 → codeboarding-0.14.1}/telemetry/events.py

@@ -171,11 +171,11 @@ def track_analysis(func):
         instance = args[0] if args else None
         command = func.__name__
         run_id = os.getenv("CODEBOARDING_RUN_ID") or kwargs.get("run_id") or getattr(instance, "run_id", None)
-        depth_level = kwargs.get("depth_level") or getattr(instance, "depth_level", None)
+        depth_cap = kwargs.get("depth_cap") or getattr(instance, "depth_cap", None)
 
         telemetry.capture(
             "analysis_started",
-            AnalysisStarted(command=command, version=_app_version(), run_id=run_id, depth_level=depth_level).model_dump(
+            AnalysisStarted(command=command, version=_app_version(), run_id=run_id, depth_cap=depth_cap).model_dump(
                 exclude_none=True
             ),
         )
@@ -208,7 +208,7 @@ def track_analysis(func):
                     input_tokens=after.input_tokens - before.input_tokens,
                     output_tokens=after.output_tokens - before.output_tokens,
                     run_id=run_id,
-                    depth_level=depth_level,
+                    depth_cap=depth_cap,
                 ).model_dump(exclude_none=True),
             )
             if exc is not None:

{codeboarding-0.14.0 → codeboarding-0.14.1}/telemetry/schemas.py

@@ -44,7 +44,7 @@ class AnalysisStarted(BaseModel):
     command: str
     version: str
     run_id: str | None = None
-    depth_level: int | None = None
+    depth_cap: int | None = None
 
 
 class AnalysisCompleted(BaseModel):
@@ -57,7 +57,7 @@ class AnalysisCompleted(BaseModel):
     input_tokens: int = 0
     output_tokens: int = 0
     run_id: str | None = None
-    depth_level: int | None = None
+    depth_cap: int | None = None
 
 
 class TokenSnapshot(BaseModel):