roam-code 8.1.0__tar.gz → 8.2.0__tar.gz

{roam_code-8.1.0 → roam_code-8.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roam-code
-Version: 8.1.0
+Version: 8.2.0
 Summary: Instant codebase comprehension for AI coding agents
 Author: CosmoHac
 License-Expression: MIT
@@ -1023,7 +1023,7 @@ Delete `.roam/` from your project root to clean up local data.
 git clone https://github.com/Cranot/roam-code.git
 cd roam-code
 pip install -e ".[dev]"   # includes pytest, ruff
-pytest tests/              # 1664 tests, Python 3.9-3.13
+pytest tests/              # 1729 tests, Python 3.9-3.13
 
 # Or use Make targets:
 make dev      # install with dev extras
@@ -1079,7 +1079,7 @@ roam-code/
 │   └── output/
 │       ├── formatter.py               # Token-efficient formatting
 │       └── sarif.py                   # SARIF 2.1.0 output
-└── tests/                             # 1664 tests across 28 test files
+└── tests/                             # 1729 tests across 30 test files
 ```
 
 </details>
@@ -1120,7 +1120,7 @@ Optional: [fastmcp](https://github.com/jlowin/fastmcp) (MCP server)
 git clone https://github.com/Cranot/roam-code.git
 cd roam-code
 pip install -e .
-pytest tests/   # All 1664 tests must pass
+pytest tests/   # All 1729 tests must pass
 ```
 
 Good first contributions: add a [Tier 1 language](src/roam/languages/) (see `go_lang.py` or `php_lang.py` as templates), improve reference resolution, add benchmark repos, extend SARIF converters, add MCP tools.

{roam_code-8.1.0 → roam_code-8.2.0}/README.md

@@ -988,7 +988,7 @@ Delete `.roam/` from your project root to clean up local data.
 git clone https://github.com/Cranot/roam-code.git
 cd roam-code
 pip install -e ".[dev]"   # includes pytest, ruff
-pytest tests/              # 1664 tests, Python 3.9-3.13
+pytest tests/              # 1729 tests, Python 3.9-3.13
 
 # Or use Make targets:
 make dev      # install with dev extras
@@ -1044,7 +1044,7 @@ roam-code/
 │   └── output/
 │       ├── formatter.py               # Token-efficient formatting
 │       └── sarif.py                   # SARIF 2.1.0 output
-└── tests/                             # 1664 tests across 28 test files
+└── tests/                             # 1729 tests across 30 test files
 ```
 
 </details>
@@ -1085,7 +1085,7 @@ Optional: [fastmcp](https://github.com/jlowin/fastmcp) (MCP server)
 git clone https://github.com/Cranot/roam-code.git
 cd roam-code
 pip install -e .
-pytest tests/   # All 1664 tests must pass
+pytest tests/   # All 1729 tests must pass
 ```
 
 Good first contributions: add a [Tier 1 language](src/roam/languages/) (see `go_lang.py` or `php_lang.py` as templates), improve reference resolution, add benchmark repos, extend SARIF converters, add MCP tools.

{roam_code-8.1.0 → roam_code-8.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "roam-code"
-version = "8.1.0"
+version = "8.2.0"
 description = "Instant codebase comprehension for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{roam_code-8.1.0 → roam_code-8.2.0}/src/roam/commands/cmd_health.py

@@ -59,12 +59,21 @@ _UTILITY_FILE_PATTERNS = (
     "resolve.py", "helpers.py", "common.py", "base.py",
 )
 
+# Paths that are NOT production code — treat as expected utilities
+_NON_PRODUCTION_PATH_PATTERNS = (
+    "tests/", "test/", "__tests__/", "spec/",
+    "dev/", "scripts/", "bin/", "benchmark/",
+    "conftest.py",
+)
+
 
 def _is_utility_path(file_path):
     """Check if a file is in a utility/infrastructure directory or is a known utility file."""
     p = file_path.replace("\\", "/").lower()
     if any(pat in p for pat in _UTILITY_PATH_PATTERNS):
         return True
+    if any(pat in p for pat in _NON_PRODUCTION_PATH_PATTERNS):
+        return True
     basename = p.rsplit("/", 1)[-1] if "/" in p else p
     return basename in _UTILITY_FILE_PATTERNS
 

{roam_code-8.1.0 → roam_code-8.2.0}/src/roam/commands/cmd_patterns.py

@@ -1,5 +1,8 @@
 """Detect common architectural patterns in the codebase symbol graph."""
 
+from __future__ import annotations
+
+import os
 import re
 from collections import defaultdict
 
@@ -10,6 +13,20 @@ from roam.output.formatter import abbrev_kind, loc, format_table, to_json, json_
 from roam.commands.resolve import ensure_index
 
 
+def _is_test_or_detector_path(file_path):
+    """Return True if file is test code or a pattern detector itself."""
+    p = file_path.replace("\\", "/").lower()
+    base = os.path.basename(p)
+    if base.startswith("test_") or base.endswith("_test.py"):
+        return True
+    if "tests/" in p or "test/" in p or "__tests__/" in p or "spec/" in p:
+        return True
+    # Exclude the patterns detector itself to avoid self-referential matches
+    if base == "cmd_patterns.py":
+        return True
+    return False
+
+
 # ---------------------------------------------------------------------------
 # Pattern detection helpers
 # ---------------------------------------------------------------------------
@@ -96,6 +113,8 @@ def _detect_factory(conn):
 
     results = []
     for r in rows:
+        if _is_test_or_detector_path(r["file_path"]):
+            continue
         # Check for outgoing edges to constructors or class instantiations
         targets = conn.execute(
             "SELECT DISTINCT t.name, t.kind FROM edges e "
@@ -287,10 +306,8 @@ def _detect_middleware(conn):
         "FROM symbols s JOIN files f ON s.file_id = f.id "
         "WHERE ("
         "  s.name LIKE '%Middleware' OR s.name LIKE '%middleware' "
-        "  OR s.name LIKE '%Handler' "
         "  OR s.name LIKE '%Interceptor' OR s.name LIKE '%interceptor' "
-        "  OR s.name LIKE '%Filter' "
-        "  OR s.name LIKE '%Pipe' OR s.name LIKE '%Pipeline' "
+        "  OR s.name LIKE '%Pipe' OR s.name LIKE '%Pipeline' OR s.name LIKE '%pipeline' "
         ") "
         "AND s.kind IN ('class', 'function', 'method')"
     ).fetchall()
@@ -304,6 +321,8 @@ def _detect_middleware(conn):
     for r in rows:
         if r["id"] in seen:
             continue
+        if _is_test_or_detector_path(r["file_path"]):
+            continue
         seen.add(r["id"])
 
         # Look for call-chain: what does this symbol call, and what calls it?
@@ -438,6 +457,8 @@ def _detect_decorator(conn):
     for r in rows:
         if r["name"] in seen:
             continue
+        if _is_test_or_detector_path(r["file_path"]):
+            continue
         seen.add(r["name"])
 
         # Count how many symbols this decorator is applied to
@@ -474,6 +495,8 @@ def _detect_decorator(conn):
     for r in wrapper_rows:
         if r["name"] in seen:
             continue
+        if _is_test_or_detector_path(r["file_path"]):
+            continue
         seen.add(r["name"])
 
         usage_count = conn.execute(

{roam_code-8.1.0 → roam_code-8.2.0}/src/roam/commands/graph_helpers.py

@@ -16,14 +16,6 @@ def build_forward_adj(conn):
     return adj
 
 
-def build_reverse_adj(conn):
-    """Build reverse adjacency list from edges table (target -> set of sources)."""
-    adj = defaultdict(set)
-    for row in conn.execute("SELECT source_id, target_id FROM edges").fetchall():
-        adj[row["target_id"]].add(row["source_id"])
-    return adj
-
-
 def bfs_reachable(adj, start_ids, max_depth=None):
     """BFS from *start_ids* through an adjacency dict.
 

{roam_code-8.1.0 → roam_code-8.2.0}/src/roam/commands/metrics_history.py

@@ -1,5 +1,8 @@
 """Collect and persist health metrics for snapshot/trend tracking."""
 
+from __future__ import annotations
+
+import os
 import subprocess
 import time
 
@@ -7,6 +10,12 @@ from roam.db.connection import find_project_root
 from roam.db.queries import UNREFERENCED_EXPORTS
 
 
+def _is_test_path(file_path):
+    """Check if a file is a test file (discovered by pytest, not imported)."""
+    base = os.path.basename(file_path).lower()
+    return base.startswith("test_") or base.endswith("_test.py")
+
+
 def collect_metrics(conn):
     """Query the DB for all health metrics and compute a health score.
 
@@ -41,8 +50,10 @@ def collect_metrics(conn):
     ).fetchall()
     bottlenecks = len(bn_rows)
 
-    # Dead exports
+    # Dead exports (filter test files — they're discovered by pytest, not imported)
     dead_rows = conn.execute(UNREFERENCED_EXPORTS).fetchall()
+    dead_rows = [r for r in dead_rows
+                 if not _is_test_path(r["file_path"])]
     dead_exports = len(dead_rows)
 
     # Layer violations
@@ -56,18 +67,43 @@ def collect_metrics(conn):
         except Exception:
             pass
 
-    # Health score: 100 minus penalties, clamped to 0-100
-    # Penalties scale with codebase size
-    penalty = 0
-    if symbols > 0:
-        penalty += min(20, cycles * 3)                          # cycles: up to 20
-        penalty += min(15, god_components * 2)                  # god: up to 15
-        penalty += min(15, bottlenecks * 2)                     # bottlenecks: up to 15
-        penalty += min(25, dead_exports * 100 / symbols)        # dead %: up to 25
-        penalty += min(15, layer_violations * 3)                # layers: up to 15
-        penalty += min(10, max(0, (cycles + god_components + bottlenecks + layer_violations) - 5))
-
-    health_score = max(0, min(100, 100 - int(penalty)))
+    # Health score: weighted geometric mean matching cmd_health.py formula.
+    # Each factor h_i = e^(-signal/scale) is a health fraction in (0,1].
+    import math
+
+    def _hf(value, scale):
+        return math.exp(-value / scale) if scale > 0 else 1.0
+
+    tangle_r = 0.0
+    if G is not None and symbols > 0:
+        try:
+            cyc_ids = set()
+            for scc in find_cycles(G):
+                cyc_ids.update(scc)
+            tangle_r = len(cyc_ids) / symbols * 100
+        except Exception:
+            pass
+
+    god_signal = god_components * 0.5
+    bn_signal = bottlenecks * 0.3
+
+    factors = [
+        (_hf(tangle_r, 10), 0.30),
+        (_hf(god_signal, 5), 0.20),
+        (_hf(bn_signal, 4), 0.15),
+        (_hf(layer_violations, 5), 0.15),
+    ]
+    # File health (if available)
+    try:
+        avg_fh = conn.execute(
+            "SELECT AVG(health_score) FROM file_stats WHERE health_score IS NOT NULL"
+        ).fetchone()[0]
+        factors.append((min(1.0, (avg_fh or 10) / 10.0), 0.20))
+    except Exception:
+        factors.append((1.0, 0.20))
+
+    log_score = sum(w * math.log(max(h, 1e-9)) for h, w in factors)
+    health_score = max(0, min(100, int(100 * math.exp(log_score))))
 
     # Tangle ratio: percentage of symbols in cycles
     tangle_ratio = 0.0

{roam_code-8.1.0 → roam_code-8.2.0}/src/roam/graph/__init__.py

@@ -8,14 +8,13 @@ from roam.graph.clusters import (
     store_clusters,
 )
 from roam.graph.cycles import (
-    condense_cycles,
     find_cycles,
     find_weakest_edge,
     format_cycles,
 )
 from roam.graph.layers import detect_layers, find_violations, format_layers
 from roam.graph.pagerank import compute_centrality, compute_pagerank, store_metrics
-from roam.graph.pathfinding import find_path, find_symbol_id, format_path
+from roam.graph.pathfinding import find_symbol_id, format_path
 
 __all__ = [
     "build_symbol_graph",
@@ -23,7 +22,6 @@ __all__ = [
     "compute_pagerank",
     "compute_centrality",
     "store_metrics",
-    "condense_cycles",
     "find_cycles",
     "find_weakest_edge",
     "format_cycles",
@@ -34,7 +32,6 @@ __all__ = [
     "detect_layers",
     "find_violations",
     "format_layers",
-    "find_path",
     "find_symbol_id",
     "format_path",
 ]

{roam_code-8.1.0 → roam_code-8.2.0}/src/roam/graph/cycles.py

@@ -100,58 +100,6 @@ def format_cycles(
     return result
 
 
-def condense_cycles(
-    G: nx.DiGraph, cycles: list[list[int]]
-) -> tuple[nx.DiGraph, dict[int, list[int]]]:
-    """Build a condensation DAG from the graph and its SCC cycles.
-
-    Uses ``nx.condensation(G)`` to collapse each SCC into a single node.
-    Each condensation node gets attributes:
-
-    - **members**: sorted list of original symbol IDs in that SCC
-    - **member_count**: number of symbols in the SCC
-    - **label**: cluster label derived from the most common name prefix
-
-    Returns ``(condensation_graph, mapping)`` where *mapping* maps each
-    condensation node ID to the list of original symbol IDs.
-    """
-    if len(G) == 0 or not cycles:
-        empty = nx.DiGraph()
-        return empty, {}
-
-    C = nx.condensation(G)
-
-    mapping: dict[int, list[int]] = {}
-    for node in C.nodes():
-        members = sorted(C.nodes[node]["members"])
-        C.nodes[node]["members"] = members
-        C.nodes[node]["member_count"] = len(members)
-
-        # Derive a cluster label from the most common name prefix
-        prefixes: list[str] = []
-        for sid in members:
-            if sid in G.nodes:
-                name = G.nodes[sid].get("name", "")
-                # Use the part before the last underscore/dot as prefix,
-                # or the full name if no separator exists
-                for sep in (".", "_"):
-                    idx = name.rfind(sep)
-                    if idx > 0:
-                        prefixes.append(name[:idx])
-                        break
-                else:
-                    prefixes.append(name)
-        if prefixes:
-            label = Counter(prefixes).most_common(1)[0][0]
-        else:
-            label = f"scc_{node}"
-        C.nodes[node]["label"] = label
-
-        mapping[node] = members
-
-    return C, mapping
-
-
 def propagation_cost(G: nx.DiGraph) -> float:
     """Compute the Propagation Cost metric (MacCormack et al. 2006).
 

{roam_code-8.1.0 → roam_code-8.2.0}/src/roam/graph/layers.py

@@ -42,34 +42,6 @@ def detect_layers(G: nx.DiGraph) -> dict[int, int]:
     return layers
 
 
-def layer_balance(layers: dict[int, int]) -> float:
-    """Compute Gini coefficient of layer sizes as a balance metric.
-
-    Returns a value in [0, 1] where 0 = perfectly balanced (all layers
-    have the same number of nodes) and 1 = maximally imbalanced (all
-    nodes in one layer).
-
-    The Gini coefficient is a standard inequality measure from economics
-    (Gini, 1912) applied here to architectural layer distribution.
-    """
-    if not layers:
-        return 0.0
-    from collections import Counter
-    sizes = sorted(Counter(layers.values()).values())
-    n = len(sizes)
-    if n <= 1:
-        return 0.0
-    total = sum(sizes)
-    if total == 0:
-        return 0.0
-    cumulative = 0.0
-    weighted_sum = 0.0
-    for i, size in enumerate(sizes):
-        cumulative += size
-        weighted_sum += (2 * (i + 1) - n - 1) * size
-    return round(weighted_sum / (n * total), 4)
-
-
 def find_violations(
     G: nx.DiGraph, layers: dict[int, int]
 ) -> list[dict]:

{roam_code-8.1.0 → roam_code-8.2.0}/src/roam/graph/pathfinding.py

@@ -26,34 +26,6 @@ def _ensure_weights(G: nx.DiGraph) -> None:
             data["weight"] = _EDGE_WEIGHTS.get(data.get("kind", ""), 2)
 
 
-def find_path(
-    G: nx.DiGraph, source_id: int, target_id: int
-) -> list[int] | None:
-    """Find the shortest path from *source_id* to *target_id*.
-
-    Prefers call edges over import edges via edge-kind weighting.
-    Tries the directed graph first; if no directed path exists, falls back to
-    the undirected projection.  Returns ``None`` when no path exists at all.
-    """
-    if source_id not in G or target_id not in G:
-        return None
-
-    _ensure_weights(G)
-
-    # Directed attempt (weighted)
-    try:
-        return list(nx.shortest_path(G, source_id, target_id, weight="weight"))
-    except nx.NetworkXNoPath:
-        pass
-
-    # Undirected fallback (weighted)
-    try:
-        undirected = G.to_undirected()
-        return list(nx.shortest_path(undirected, source_id, target_id, weight="weight"))
-    except (nx.NetworkXNoPath, nx.NodeNotFound):
-        return None
-
-
 def find_k_paths(
     G: nx.DiGraph, source_id: int, target_id: int, k: int = 3
 ) -> list[list[int]]:

{roam_code-8.1.0 → roam_code-8.2.0}/src/roam/index/file_roles.py

@@ -76,9 +76,10 @@ _PATH_PATTERNS: list[tuple[re.Pattern[str], str]] = [
     (re.compile(r"(^|/)samples/"), ROLE_EXAMPLES),
     (re.compile(r"(^|/)sample/"), ROLE_EXAMPLES),
 
-    # Scripts / bin
+    # Scripts / bin / dev tools
     (re.compile(r"(^|/)scripts/"), ROLE_SCRIPTS),
     (re.compile(r"(^|/)bin/"), ROLE_SCRIPTS),
+    (re.compile(r"(^|/)dev/"), ROLE_SCRIPTS),
 
     # Build / dist output
     (re.compile(r"(^|/)build/"), ROLE_BUILD),

{roam_code-8.1.0 → roam_code-8.2.0}/src/roam/index/git_stats.py

@@ -553,70 +553,6 @@ def get_blame_for_file(
     return entries
 
 
-def get_symbol_blame(
-    conn: sqlite3.Connection, project_root: Path, symbol_id: int
-) -> dict:
-    """Get aggregated blame info for a symbol's line range.
-
-    Returns a dict keyed by author::
-
-        {
-            "author_name": {
-                "lines": int,
-                "commits": set_count,
-                "first_date": int (epoch),
-                "last_date": int (epoch),
-            }
-        }
-    """
-    row = conn.execute(
-        "SELECT s.line_start, s.line_end, f.path "
-        "FROM symbols s JOIN files f ON s.file_id = f.id "
-        "WHERE s.id = ?",
-        (symbol_id,),
-    ).fetchone()
-    if row is None:
-        return {}
-
-    line_start = row[0] if not isinstance(row, sqlite3.Row) else row["line_start"]
-    line_end = row[1] if not isinstance(row, sqlite3.Row) else row["line_end"]
-    file_path = row[2] if not isinstance(row, sqlite3.Row) else row["path"]
-
-    if line_start is None or line_end is None:
-        return {}
-
-    blame = get_blame_for_file(project_root, file_path)
-    if not blame:
-        return {}
-
-    # Filter to the symbol's line range (1-indexed)
-    relevant = blame[line_start - 1: line_end]
-
-    authors: dict[str, dict] = {}
-    for entry in relevant:
-        author = entry["author"]
-        if author not in authors:
-            authors[author] = {
-                "lines": 0,
-                "commits": set(),
-                "first_date": entry["timestamp"],
-                "last_date": entry["timestamp"],
-            }
-        info = authors[author]
-        info["lines"] += 1
-        info["commits"].add(entry["commit_hash"])
-        if entry["timestamp"] < info["first_date"]:
-            info["first_date"] = entry["timestamp"]
-        if entry["timestamp"] > info["last_date"]:
-            info["last_date"] = entry["timestamp"]
-
-    # Convert commit sets to counts for JSON-friendliness
-    for info in authors.values():
-        info["commits"] = len(info["commits"])
-
-    return authors
-
-
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------