codeboarding 0.13.3__tar.gz → 0.13.4__tar.gz

{codeboarding-0.13.3/codeboarding.egg-info → codeboarding-0.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.13.3
+Version: 0.13.4
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT
@@ -73,6 +73,7 @@ Dynamic: license-file
 # CodeBoarding
 
 [![Website](https://img.shields.io/badge/Site-CodeBoarding.org-5865F2?style=for-the-badge&logoColor=white)](https://codeboarding.org)
+[![Web platform](https://img.shields.io/badge/Web%20platform-app.codeboarding.org-2563EB?style=for-the-badge&logoColor=white)](https://app.codeboarding.org)
 [![Discord](https://img.shields.io/badge/Discord-Join%20Us-5865F2?style=for-the-badge&logoColor=white)](https://discord.gg/T5zHTJYFuy)
 [![GitHub](https://img.shields.io/badge/GitHub-CodeBoarding-181717?style=for-the-badge&logo=github&logoColor=white)](https://github.com/CodeBoarding/CodeBoarding)
 
@@ -130,6 +131,9 @@ codeboarding full --local /path/to/repo
 codeboarding full https://github.com/user/repo
 ```
 
+To explore the result interactively, open the [web platform](https://app.codeboarding.org) and load the
+generated `.codeboarding/analysis.json` — it is parsed in your browser, nothing is uploaded.
+
 ### Python API
 
 ```python

{codeboarding-0.13.3 → codeboarding-0.13.4}/PYPI.md

@@ -1,6 +1,7 @@
 # CodeBoarding
 
 [![Website](https://img.shields.io/badge/Site-CodeBoarding.org-5865F2?style=for-the-badge&logoColor=white)](https://codeboarding.org)
+[![Web platform](https://img.shields.io/badge/Web%20platform-app.codeboarding.org-2563EB?style=for-the-badge&logoColor=white)](https://app.codeboarding.org)
 [![Discord](https://img.shields.io/badge/Discord-Join%20Us-5865F2?style=for-the-badge&logoColor=white)](https://discord.gg/T5zHTJYFuy)
 [![GitHub](https://img.shields.io/badge/GitHub-CodeBoarding-181717?style=for-the-badge&logo=github&logoColor=white)](https://github.com/CodeBoarding/CodeBoarding)
 
@@ -58,6 +59,9 @@ codeboarding full --local /path/to/repo
 codeboarding full https://github.com/user/repo
 ```
 
+To explore the result interactively, open the [web platform](https://app.codeboarding.org) and load the
+generated `.codeboarding/analysis.json` — it is parsed in your browser, nothing is uploaded.
+
 ### Python API
 
 ```python

{codeboarding-0.13.3 → codeboarding-0.13.4}/README.md

@@ -4,7 +4,7 @@ See what your AI is building before it breaks.
 
 CodeBoarding gives developers and coding agents a visual map of a codebase. It combines static analysis with LLM reasoning to generate architecture diagrams, component-level documentation, and navigable outputs you can use in your IDE, CI, and docs.
 
-[Website](https://codeboarding.org) <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=0855d476-b2d0-44cc-b93d-69b47504719c" width="0" height="0" /> · [Open VSX extension](https://open-vsx.org/extension/CodeBoarding/codeboarding) <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=ce87464c-2792-46b0-9ea2-87eefe853d7e" width="0" height="0" /> · [Explore examples](https://codeboarding.org/diagrams) · [VS Code extension](https://marketplace.visualstudio.com/items?itemName=Codeboarding.codeboarding) <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=8a3d26e0-6f6b-49c0-8482-114445de56a5" width="0" height="0" /> · [GitHub Action](https://github.com/marketplace/actions/codeboarding-action) ·[Discord](https://discord.gg/T5zHTJYFuy)
+[Website](https://codeboarding.org) <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=0855d476-b2d0-44cc-b93d-69b47504719c" width="0" height="0" /> · [Web platform](https://app.codeboarding.org) · [Open VSX extension](https://open-vsx.org/extension/CodeBoarding/codeboarding) <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=ce87464c-2792-46b0-9ea2-87eefe853d7e" width="0" height="0" /> · [Explore examples](https://codeboarding.org/diagrams) · [VS Code extension](https://marketplace.visualstudio.com/items?itemName=Codeboarding.codeboarding) <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=8a3d26e0-6f6b-49c0-8482-114445de56a5" width="0" height="0" /> · [GitHub Action](https://github.com/marketplace/actions/codeboarding-action) · [Discord](https://discord.gg/T5zHTJYFuy)
 
 [![CodeBoarding demo](https://gist.githubusercontent.com/ivanmilevtues/1c4f921066613516cfd7b938014a6877/raw/611aec7711556807860ff2e1679a5dc4c0c23fed/CodeBoarding_extension_demo.gif)](https://open-vsx.org/extension/CodeBoarding/codeboarding) <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=ce87464c-2792-46b0-9ea2-87eefe853d7e" width="0" height="0" />
 
@@ -91,7 +91,9 @@ codeboarding-setup
 codeboarding full --local /path/to/repo
 ```
 
-Output is written to `/path/to/repo/.codeboarding/`.
+Output is written to `/path/to/repo/.codeboarding/`. To explore it interactively, open the
+[web platform](https://app.codeboarding.org) and drop in the generated `analysis.json` — it stays
+in your browser, nothing is uploaded. (The CLI prints this reminder after every successful run.)
 
 `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.
 
@@ -150,6 +152,7 @@ python main.py full https://github.com/pytorch/pytorch
 ## Where to use it
 
 - [CLI](https://github.com/CodeBoarding/CodeBoarding) for local analysis, automation, and CI workflows.
+- [Web platform](https://app.codeboarding.org) to explore any analysis in the browser — open a public repo, load an `analysis.json`, or review an architecture diff on a pull request.
 - [VS Code extension](https://marketplace.visualstudio.com/items?itemName=Codeboarding.codeboarding) <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=8a3d26e0-6f6b-49c0-8482-114445de56a5" width="0" height="0" /> for in-editor visual architecture.
 - [GitHub Action](https://github.com/marketplace/actions/codeboarding-action) to keep diagrams updated in CI.
 
@@ -163,6 +166,7 @@ python main.py full https://github.com/pytorch/pytorch
 - Visualized 800+ open-source repositories.
 - Browse generated examples in [GeneratedOnBoardings](https://github.com/CodeBoarding/GeneratedOnBoardings).
 - Try the hosted explorer at [codeboarding.org/diagrams](https://codeboarding.org/diagrams) <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=0855d476-b2d0-44cc-b93d-69b47504719c" width="0" height="0" />.
+- Open any public repo that has a committed `.codeboarding/analysis.json` at [app.codeboarding.org](https://app.codeboarding.org) — no install, no login. This repo included: [app.codeboarding.org/CodeBoarding/CodeBoarding](https://app.codeboarding.org/CodeBoarding/CodeBoarding).
 
 ## Telemetry
 

{codeboarding-0.13.3 → codeboarding-0.13.4}/agents/incremental_agent.py

@@ -40,6 +40,11 @@ from agents.prompts import (
     get_system_message,
 )
 from agents.relation_edges import index_relation_endpoints, preserve_unchanged_relations
+from static_analyzer.cluster_relations import (
+    build_node_to_component_map,
+    build_owner_index,
+    prune_ungrounded_edges,
+)
 from agents.scope_ids import ROOT_SCOPE_ID
 from agents.validation import ValidationContext, validate_relations
 from diagram_analysis.file_index import build_files_index
@@ -137,12 +142,9 @@ class IncrementalAgent(ClusterMethodsMixin, CodeBoardingAgent):
                 continue
             if operation.action == ScopeOperationAction.NOOP:
                 component = components_by_id.get(operation.component_id or "")
-                if component is not None:
-                    component.source_cluster_ids = CodeBoardingClusterIds.sort(
-                        set(component.source_cluster_ids) | set(_operation_source_cluster_ids(scope_id, operation))
-                    )
-                    if component.component_id:
-                        refresh_ids.add(component.component_id)
+                if component is None:
+                    continue
+                self._sync_noop_component_cluster_ids(scope_id, component, operation, refresh_ids)
                 continue
 
             component = components_by_id.get(operation.component_id or "")
@@ -209,6 +211,20 @@ class IncrementalAgent(ClusterMethodsMixin, CodeBoardingAgent):
             new_component_ids.add(component.component_id)
             components_by_id[component.component_id] = component
 
+    def _sync_noop_component_cluster_ids(
+        self,
+        scope_id: str,
+        component: Component,
+        operation: ScopeOperation,
+        refresh_ids: set[str],
+    ) -> None:
+        merged_cluster_ids = CodeBoardingClusterIds.sort(
+            set(component.source_cluster_ids) | set(_operation_source_cluster_ids(scope_id, operation))
+        )
+        if merged_cluster_ids != component.source_cluster_ids and component.component_id:
+            refresh_ids.add(component.component_id)
+        component.source_cluster_ids = merged_cluster_ids
+
     @trace
     def detail_new_components(self, components: list[Component]) -> None:
         """Replace new components' provisional names and descriptions in one LLM call."""
@@ -383,6 +399,17 @@ class IncrementalAgent(ClusterMethodsMixin, CodeBoardingAgent):
             for relation in scope.components_relations
             if relation.src_id and relation.dst_id
         }
+        # Also keyed by NAME. Ids are assigned per run by `assign_relation_ids`, so a
+        # re-partition can hand the same two components different numbers; the id lookup then
+        # misses and the pair is treated as brand new, which re-rolls its wording. Measured on
+        # `referenced-symbol-deleted`: 9 statically-backed relations whose call set was
+        # byte-identical came back re-worded for exactly this reason. Names survive
+        # renumbering, so they are the fallback identity.
+        baseline_by_names = {
+            (relation.src_name, relation.dst_name): relation.model_copy(deep=True)
+            for relation in scope.components_relations
+            if relation.src_name and relation.dst_name
+        }
 
         if context.changed_ids:
             cluster_analysis = _cluster_analysis_for_scope(scope, scope_name, context.cluster_results)
@@ -404,20 +431,52 @@ class IncrementalAgent(ClusterMethodsMixin, CodeBoardingAgent):
 
         if baseline_by_pair:
             live_ids = {component.component_id for component in scope.components if component.component_id}
+            # A relation is ADDED or REMOVED because code changed, not because a partitioner
+            # moved untouched methods around. `context.changed_ids` carries both — it is the
+            # right scope to re-derive, and the wrong reason to change the edge set — so the
+            # preservation gate sees only components the COMMIT reached. Components that are
+            # new or gone keep their ids here: they are changes the commit does account for.
+            changed_component_ids = {
+                component.component_id
+                for component in scope.components
+                if component.component_id
+                and any(
+                    method.qualified_name in (changed_members or set())
+                    for group in component.file_methods
+                    for method in group.methods
+                )
+            }
+            commit_changed = changed_component_ids | (set(context.changed_ids) - live_ids)
             live_qnames = {
                 qualified_name
                 for cluster_result in context.cluster_results.values()
                 for members in cluster_result.clusters.values()
                 for qualified_name in members
             }
+            for relation in scope.components_relations:
+                # Carry the baseline forward when regenerated component ids changed but names did not.
+                pair = (relation.src_id, relation.dst_id)
+                if pair not in baseline_by_pair:
+                    by_name = baseline_by_names.get((relation.src_name, relation.dst_name))
+                    if by_name is not None:
+                        baseline_by_pair[pair] = by_name
             scope.components_relations = preserve_unchanged_relations(
                 scope.components_relations,
                 baseline_by_pair,
-                set(context.changed_ids),
+                commit_changed,
                 live_ids,
                 live_qnames,
                 changed_members,
             )
+            # Preservation runs after the grounding filters and re-injects baseline edges, so
+            # the assembled list is filtered once more — otherwise a baseline's invented or
+            # mis-attributed edges survive every update that leaves their methods alone.
+            scope.components_relations = prune_ungrounded_edges(
+                scope.components_relations,
+                build_owner_index(build_node_to_component_map(scope)),
+                self.reference_resolver.keep_relation_edge,
+                changed_members or set(),
+            )
             rels = scope.components_relations
         return rels
 
@@ -793,6 +852,7 @@ def _scrub_one_analysis(analysis: AnalysisInsights, live_files: set[str]) -> set
     """Drop dead-file references in one analysis and return dropped paths."""
     dropped: set[str] = set()
     for component in analysis.components:
+        had_methods = any(group.methods for group in component.file_methods)
         kept_groups = []
         for group in component.file_methods:
             if group.file_path in live_files:
@@ -805,6 +865,8 @@ def _scrub_one_analysis(analysis: AnalysisInsights, live_files: set[str]) -> set
             for key_entity in component.key_entities
             if key_entity.reference_file is None or key_entity.reference_file in live_files
         ]
+        if had_methods and not any(group.methods for group in component.file_methods):
+            component.source_cluster_ids = []
     dropped |= {file_path for file_path in analysis.files if file_path not in live_files}
     analysis.files = {file_path: entry for file_path, entry in analysis.files.items() if file_path in live_files}
     return dropped
@@ -813,17 +875,15 @@ def _scrub_one_analysis(analysis: AnalysisInsights, live_files: set[str]) -> set
 def prune_empty_components(
     root_analysis: AnalysisInsights,
     sub_analyses: dict[str, AnalysisInsights],
-    protected_empty_ids: set[str] | None = None,
 ) -> set[str]:
-    """Remove components with no methods and strip relations pointing to them."""
+    """Remove components with neither members nor live cluster lineage."""
     removed_ids: set[str] = set()
-    protected_empty_ids = protected_empty_ids or set()
 
     def has_methods(component: Component) -> bool:
         return (
             any(group.methods for group in component.file_methods)
             or bool(component.key_entities)
-            or bool(component.component_id in protected_empty_ids and component.source_cluster_ids)
+            or bool(component.source_cluster_ids)
         )
 
     def collect_empty(analysis: AnalysisInsights) -> None:

{codeboarding-0.13.3 → codeboarding-0.13.4}/agents/relation_edges.py

@@ -55,7 +55,8 @@ def index_relation_endpoints(analysis: AnalysisInsights, repo_dir: Path) -> None
 def _is_internal_self_relation(relation: Relation) -> bool:
     """A component related to itself by concrete intra-component calls.
 
-    The backing edges are real CFG calls whose endpoints currently fall in the same
+    Its supporting calls — the concrete method-to-method calls stored under the relation —
+    are real CFG calls whose endpoints currently fall in the same
     component, so at this granularity there is no cross-component connection to draw — the
     loop is the residue of a rollup that collapsed a cross-child edge onto its shared parent.
     The CFG still holds every such edge, so expanding the component re-materialises it across
@@ -76,7 +77,7 @@ def drop_internal_self_relations(relations: list[Relation]) -> list[Relation]:
 def _relation_backing_survives(relation: Relation, live_qnames: set[str]) -> bool:
     """Whether a baseline relation's static backing still exists in live code.
 
-    A relation restored verbatim keeps its call edges. If the only edges connecting the two
+    A relation is supported by concrete method-to-method calls; restoring it verbatim keeps them. If the only edges connecting the two
     components pointed at a symbol since deleted, restoring the relation resurrects an edge
     citing code that is gone — a phantom. A relation with no static edge at all is a
     runtime/config relation with nothing to invalidate, so it is left alone.
@@ -90,6 +91,7 @@ def _relation_backing_survives(relation: Relation, live_qnames: set[str]) -> boo
 
 
 def _backing_edge_pairs(relation: Relation) -> set[tuple[str, str]]:
+    """The (source, target) method pairs supporting this relation — the calls under the arrow."""
     edges = relation.all_edges or relation.key_edges
     return {(edge.source.qualified_name, edge.target.qualified_name) for edge in edges}
 
@@ -107,7 +109,65 @@ def _relation_edges_unmoved(rebuilt: Relation, previous: Relation) -> bool:
 
 
 def _edge_touches_changed_method(edge: RelationEdge, changed_members: set[str]) -> bool:
-    return edge.source.qualified_name in changed_members or edge.target.qualified_name in changed_members
+    return edge.source.qualified_name in changed_members
+
+
+def _restore_baseline_orientation(relation: Relation, baseline_by_pair: dict) -> Relation:
+    """Put an ungrounded relation back the way round the reader last saw it.
+
+    Why only ungrounded ones: a statically-backed relation takes its direction from real CFG
+    edges, so the arrow means something and must not be touched. A runtime/config relation has
+    no call to fix it, so the model picks an orientation afresh each run — and a swap keyed on
+    the ordered pair reads as one relation deleted and another added. On the reported case
+    (CodeBoarding-action#65) two of the five changed edges were exactly that: the same two
+    component pairs with their arrows reversed and relabelled.
+
+    Applied only when the fresh relation carries no backing edges at all, because an edge is
+    what would make the direction a claim rather than a phrasing — flipping a relation that has
+    one would point its edges the wrong way.
+    """
+    if relation.is_static or relation.all_edges or relation.key_edges:
+        return relation
+    flipped = baseline_by_pair.get((relation.dst_id, relation.src_id))
+    if flipped is None or flipped.is_static or flipped.all_edges or flipped.key_edges:
+        return relation
+    return relation.model_copy(
+        update={
+            "src_id": flipped.src_id,
+            "dst_id": flipped.dst_id,
+            "src_name": flipped.src_name,
+            "dst_name": flipped.dst_name,
+            "relation": flipped.relation,
+            "evidence": flipped.evidence,
+        }
+    )
+
+
+def _filter_edges_touched_by_change(relation: Relation, changed_members: set[str]) -> Relation:
+    """Keep only the edges a code change can account for, for a pair with no baseline.
+
+    Why: a call lives in its source method's body, so an edge can only appear when one of its
+    endpoints changed. ``_reconcile_unchanged_edges`` enforces that by falling back to the
+    baseline, but re-clustering invents component-pairs that have no baseline to fall back to —
+    there every re-attributed edge would otherwise enter as if the commit had written it.
+    """
+    return relation.model_copy(
+        update={
+            "all_edges": [e for e in relation.all_edges if _edge_touches_changed_method(e, changed_members)],
+            "key_edges": [e for e in relation.key_edges if _edge_touches_changed_method(e, changed_members)],
+        }
+    )
+
+
+def _commit_deleted_the_backing(rebuilt: Relation, previous: Relation, changed_members: set[str]) -> bool:
+    """Return whether a changed source removed every baseline backing edge.
+
+    A call belongs to its source method, so only lost edges from changed sources prove deletion.
+    """
+    baseline_edges = previous.all_edges or previous.key_edges
+    if not baseline_edges or rebuilt.all_edges or rebuilt.key_edges or rebuilt.evidence.strip():
+        return False
+    return any(_edge_touches_changed_method(edge, changed_members) for edge in baseline_edges)
 
 
 def _reconcile_unchanged_edges(fresh: Relation, previous: Relation, changed_members: set[str]) -> Relation:
@@ -160,6 +220,9 @@ def preserve_unchanged_relations(
     their inter-component edges are byte-identical. Gating on the pair's own edges instead of
     on its endpoints' change flags is what keeps those untouched connections stable.
 
+    A pair whose changed source lost every baseline call is dropped unless the rebuild supplies
+    alternate runtime/config evidence.
+
     A baseline relation between two unchanged, still-live components that regeneration
     dropped is restored — but only when its backing edges still exist in live code. The
     deterministic rebuild drops a pair when the code connecting the two components was
@@ -176,6 +239,8 @@ def preserve_unchanged_relations(
     kept: list[Relation] = []
     rebuilt_pairs: set[tuple[str, str]] = set()
     for relation in rebuilt_relations:
+        if (relation.src_id, relation.dst_id) not in baseline_by_pair:
+            relation = _restore_baseline_orientation(relation, baseline_by_pair)
         pair = (relation.src_id, relation.dst_id)
         rebuilt_pairs.add(pair)
         previous = baseline_by_pair.get(pair)
@@ -183,8 +248,14 @@ def preserve_unchanged_relations(
             # No baseline for this pair. A genuinely new connection into a changed area is
             # kept; a fresh edge invented between two untouched components is a re-attribution
             # artifact and is dropped.
-            if touches_change(*pair):
-                kept.append(relation)
+            if not touches_change(*pair):
+                continue
+            if changed_members is not None:
+                relation = _filter_edges_touched_by_change(relation, changed_members)
+                # Nothing survived and nothing else is claimed: the pair asserts no connection.
+                if not relation.all_edges and not relation.key_edges and not relation.evidence.strip():
+                    continue
+            kept.append(relation)
             continue
         # Every edge between two byte-identical methods is taken from the baseline; only edges
         # that touch a changed/added/deleted method come from the fresh rebuild. This stops
@@ -192,9 +263,23 @@ def preserve_unchanged_relations(
         # pairs alike.
         if changed_members is not None:
             relation = _reconcile_unchanged_edges(relation, previous, changed_members)
-        # Keep the reader's wording unless a real, code-backed edge change re-worded it: an
-        # untouched pair, or one whose edges came through unmoved, carries its label over.
-        if not touches_change(*pair) or _relation_edges_unmoved(relation, previous):
+            if _commit_deleted_the_backing(relation, previous, changed_members):
+                continue
+        # Keep the reader's wording unless this pair's own supporting calls moved.
+        #
+        # The supporting calls are the concrete method-to-method calls under the relation — the
+        # ones that show WHERE one component reaches the other. They are the only evidence that
+        # the connection itself changed, so they are what decides whether it may be re-worded.
+        # Gating on the endpoint components' change flags instead re-words far more: a component
+        # is flagged for any edit to a file it merely co-owns, so deleting one function re-worded
+        # 17 of the relations in `referenced-symbol-deleted` whose calls had not moved at all.
+        # A pair with no supporting calls has nothing that could have moved, so its wording is
+        # kept too — an edgeless runtime relation is prose, and re-rolling prose is the churn.
+        if (
+            not touches_change(*pair)
+            or _relation_edges_unmoved(relation, previous)
+            or (not _backing_edge_pairs(relation) and not relation.evidence.strip())
+        ):
             relation = relation.model_copy(update={"relation": previous.relation, "evidence": previous.evidence})
         kept.append(relation)
     for pair, relation in baseline_by_pair.items():

{codeboarding-0.13.3 → codeboarding-0.13.4/codeboarding.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.13.3
+Version: 0.13.4
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT
@@ -73,6 +73,7 @@ Dynamic: license-file
 # CodeBoarding
 
 [![Website](https://img.shields.io/badge/Site-CodeBoarding.org-5865F2?style=for-the-badge&logoColor=white)](https://codeboarding.org)
+[![Web platform](https://img.shields.io/badge/Web%20platform-app.codeboarding.org-2563EB?style=for-the-badge&logoColor=white)](https://app.codeboarding.org)
 [![Discord](https://img.shields.io/badge/Discord-Join%20Us-5865F2?style=for-the-badge&logoColor=white)](https://discord.gg/T5zHTJYFuy)
 [![GitHub](https://img.shields.io/badge/GitHub-CodeBoarding-181717?style=for-the-badge&logo=github&logoColor=white)](https://github.com/CodeBoarding/CodeBoarding)
 
@@ -130,6 +131,9 @@ codeboarding full --local /path/to/repo
 codeboarding full https://github.com/user/repo
 ```
 
+To explore the result interactively, open the [web platform](https://app.codeboarding.org) and load the
+generated `.codeboarding/analysis.json` — it is parsed in your browser, nothing is uploaded.
+
 ### Python API
 
 ```python

{codeboarding-0.13.3 → codeboarding-0.13.4}/codeboarding.egg-info/SOURCES.txt

@@ -97,6 +97,7 @@ diagram_analysis/io_utils.py
 diagram_analysis/run_context.py
 diagram_analysis/run_mode.py
 diagram_analysis/scope_plan.py
+diagram_analysis/tree_shape.py
 health/__init__.py
 health/config.py
 health/models.py
@@ -189,6 +190,7 @@ tests/test_main.py
 tests/test_pyproject_packages.py
 tests/test_registry_coverage.py
 tests/test_telemetry_events.py
+tests/test_telemetry_service.py
 tests/test_tool_registry.py
 tests/test_user_config.py
 tests/test_view_instructions.py