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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roam-code
-Version: 8.0.1
+Version: 8.1.0
 Summary: Instant codebase comprehension for AI coding agents
 Author: CosmoHac
 License-Expression: MIT

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "roam-code"
-version = "8.0.1"
+version = "8.1.0"
 description = "Instant codebase comprehension for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -55,6 +55,9 @@ where = ["src"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-q --tb=short"
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+]
 
 [tool.ruff]
 target-version = "py39"

{roam_code-8.0.1 → roam_code-8.1.0}/src/roam/commands/cmd_complexity.py

@@ -5,6 +5,8 @@ functions/methods by cognitive complexity to identify the hardest-to-
 understand code in the project.
 """
 
+from __future__ import annotations
+
 import click
 
 from roam.db.connection import open_db
@@ -12,6 +14,15 @@ from roam.commands.resolve import ensure_index
 from roam.output.formatter import loc, abbrev_kind, to_json, json_envelope
 
 
+def _safe_metric(row, key, default=0.0):
+    """Safely access a metric column that may not exist in older DBs."""
+    try:
+        v = row[key]
+        return v if v is not None else default
+    except (KeyError, IndexError):
+        return default
+
+
 def _severity(score: float) -> str:
     """Map cognitive complexity score to a severity label."""
     if score >= 25:
@@ -144,11 +155,11 @@ def complexity(ctx, target, limit, threshold, by_file, bumpy_road):
                         "return_count": r["return_count"],
                         "bool_op_count": r["bool_op_count"],
                         "callback_depth": r["callback_depth"],
-                        "cyclomatic_density": r["cyclomatic_density"] or 0,
-                        "halstead_volume": r["halstead_volume"] or 0,
-                        "halstead_difficulty": r["halstead_difficulty"] or 0,
-                        "halstead_effort": r["halstead_effort"] or 0,
-                        "halstead_bugs": r["halstead_bugs"] or 0,
+                        "cyclomatic_density": _safe_metric(r, "cyclomatic_density"),
+                        "halstead_volume": _safe_metric(r, "halstead_volume"),
+                        "halstead_difficulty": _safe_metric(r, "halstead_difficulty"),
+                        "halstead_effort": _safe_metric(r, "halstead_effort"),
+                        "halstead_bugs": _safe_metric(r, "halstead_bugs"),
                         "severity": _severity(r["cognitive_complexity"]),
                     }
                     for r in rows
@@ -181,11 +192,11 @@ def complexity(ctx, target, limit, threshold, by_file, bumpy_road):
                 factors.append(f"params={r['param_count']}")
             if r["return_count"] >= 4:
                 factors.append(f"ret={r['return_count']}")
-            cd = r["cyclomatic_density"]
-            if cd and cd > 0.15:
+            cd = _safe_metric(r, "cyclomatic_density")
+            if cd > 0.15:
                 factors.append(f"density={cd:.2f}")
-            hv = r["halstead_volume"]
-            if hv and hv > 500:
+            hv = _safe_metric(r, "halstead_volume")
+            if hv > 500:
                 factors.append(f"H.vol={hv:.0f}")
 
             factor_str = f" ({', '.join(factors)})" if factors else ""

{roam_code-8.0.1 → roam_code-8.1.0}/src/roam/commands/cmd_dead.py

@@ -40,6 +40,20 @@ _API_PREFIXES = ("get", "use", "create", "validate", "fetch", "update",
                  "delete", "find", "check", "make", "build", "parse")
 
 
+_ABC_METHOD_NAMES = frozenset({
+    "language_name", "file_extensions", "extract_symbols", "extract_references",
+    "get_docstring", "get_signature", "node_text",
+    "detect", "supported_bridges",
+    "resolve_cross_language", "get_bridge_edges",
+})
+
+
+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 _dead_action(r, file_imported):
     """Compute actionable verdict and confidence % for a dead symbol.
 
@@ -62,6 +76,18 @@ def _dead_action(r, file_imported):
     except (KeyError, IndexError):
         kind = ""
 
+    # Test file symbols — discovered by pytest, never imported directly
+    if _is_test_path(r["file_path"]):
+        return "INTENTIONAL", 10
+
+    # CLI command functions — loaded dynamically via LazyGroup/importlib
+    if base.startswith("cmd_") and kind == "function":
+        return "INTENTIONAL", 20
+
+    # ABC method overrides — called polymorphically, not by direct import
+    if kind == "method" and name in _ABC_METHOD_NAMES:
+        return "INTENTIONAL", 10
+
     # Entry point / lifecycle hooks (check original case for camelCase hooks)
     if name in _ENTRY_NAMES or name_lower in _ENTRY_NAMES:
         return "INTENTIONAL", 60
@@ -251,6 +277,8 @@ def _analyze_dead(conn):
     Returns (high, low, imported_files) where high/low are lists of Row objects.
     """
     rows = conn.execute(UNREFERENCED_EXPORTS).fetchall()
+    # Exclude test files — their symbols are discovered by pytest, not imported
+    rows = [r for r in rows if not _is_test_path(r["file_path"])]
     if not rows:
         return [], [], set()
 

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

@@ -52,13 +52,21 @@ _FRAMEWORK_NAMES = frozenset({
 _UTILITY_PATH_PATTERNS = (
     "composables/", "utils/", "services/", "lib/", "helpers/",
     "shared/", "config/", "core/", "hooks/", "stores/",
+    "output/", "db/", "common/", "internal/", "infra/",
+)
+
+_UTILITY_FILE_PATTERNS = (
+    "resolve.py", "helpers.py", "common.py", "base.py",
 )
 
 
 def _is_utility_path(file_path):
-    """Check if a file is in a utility/infrastructure directory."""
+    """Check if a file is in a utility/infrastructure directory or is a known utility file."""
     p = file_path.replace("\\", "/").lower()
-    return any(pat in p for pat in _UTILITY_PATH_PATTERNS)
+    if any(pat in p for pat in _UTILITY_PATH_PATTERNS):
+        return True
+    basename = p.rsplit("/", 1)[-1] if "/" in p else p
+    return basename in _UTILITY_FILE_PATTERNS
 
 
 def _percentile(sorted_values, pct):

{roam_code-8.0.1 → roam_code-8.1.0}/src/roam/languages/python_lang.py

@@ -333,6 +333,9 @@ class PythonExtractor(LanguageExtractor):
                 self._extract_from_import(child, source, refs, scope_name)
             elif child.type == "call":
                 self._extract_call(child, source, refs, scope_name)
+            elif child.type == "decorated_definition":
+                self._extract_decorator_refs(child, source, refs, scope_name)
+                self._walk_refs(child, source, file_path, refs, scope_name)
             else:
                 # Recurse, updating scope for classes/functions
                 new_scope = scope_name
@@ -341,8 +344,77 @@ class PythonExtractor(LanguageExtractor):
                     if n:
                         fname = self.node_text(n, source)
                         new_scope = f"{scope_name}.{fname}" if scope_name else fname
+                    # Extract type annotation refs from function parameters and return
+                    if child.type == "function_definition":
+                        self._extract_type_refs(child, source, refs, new_scope)
                 self._walk_refs(child, source, file_path, refs, new_scope)
 
+    def _extract_decorator_refs(self, decorated_node, source, refs, scope_name):
+        """Extract references from decorators (e.g., @cache, @app.route)."""
+        for child in decorated_node.children:
+            if child.type == "decorator":
+                # The decorator content is after the '@'
+                for sub in child.children:
+                    if sub.type == "identifier":
+                        name = self.node_text(sub, source)
+                        refs.append(self._make_reference(
+                            target_name=name,
+                            kind="call",
+                            line=sub.start_point[0] + 1,
+                            source_name=scope_name,
+                        ))
+                    elif sub.type == "attribute":
+                        name = self.node_text(sub, source)
+                        refs.append(self._make_reference(
+                            target_name=name,
+                            kind="call",
+                            line=sub.start_point[0] + 1,
+                            source_name=scope_name,
+                        ))
+                    elif sub.type == "call":
+                        self._extract_call(sub, source, refs, scope_name)
+
+    def _extract_type_refs(self, func_node, source, refs, scope_name):
+        """Extract references from type annotations in function signatures."""
+        # Parameter type annotations
+        params = func_node.child_by_field_name("parameters")
+        if params:
+            for param in params.children:
+                type_node = param.child_by_field_name("type")
+                if type_node:
+                    self._walk_type_node(type_node, source, refs, scope_name)
+
+        # Return type annotation
+        ret = func_node.child_by_field_name("return_type")
+        if ret:
+            self._walk_type_node(ret, source, refs, scope_name)
+
+    def _walk_type_node(self, node, source, refs, scope_name):
+        """Walk a type annotation node and extract type references."""
+        if node.type == "identifier":
+            name = self.node_text(node, source)
+            # Skip builtins that don't create real references
+            if name not in ("int", "str", "float", "bool", "bytes", "None",
+                            "list", "dict", "set", "tuple", "type", "object"):
+                refs.append(self._make_reference(
+                    target_name=name,
+                    kind="type_ref",
+                    line=node.start_point[0] + 1,
+                    source_name=scope_name,
+                ))
+        elif node.type == "attribute":
+            name = self.node_text(node, source)
+            refs.append(self._make_reference(
+                target_name=name,
+                kind="type_ref",
+                line=node.start_point[0] + 1,
+                source_name=scope_name,
+            ))
+        else:
+            # Recurse into generic types like List[Item], Optional[str], etc.
+            for child in node.children:
+                self._walk_type_node(child, source, refs, scope_name)
+
     def _extract_import(self, node, source, refs, scope_name):
         # import x, import x.y, import x as y
         for child in node.children:

{roam_code-8.0.1 → roam_code-8.1.0}/src/roam_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roam-code
-Version: 8.0.1
+Version: 8.1.0
 Summary: Instant codebase comprehension for AI coding agents
 Author: CosmoHac
 License-Expression: MIT