roam-code 12.33__tar.gz → 12.35__tar.gz

{roam_code-12.33 → roam_code-12.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roam-code
-Version: 12.33
+Version: 12.35
 Summary: Instant codebase comprehension for AI coding agents
 Author: CosmoHac
 License-Expression: Apache-2.0

{roam_code-12.33 → roam_code-12.35}/pyproject.toml

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

{roam_code-12.33 → roam_code-12.35}/src/roam/competitor_site_data.py

@@ -1362,8 +1362,8 @@ MAP_METADATA: dict[str, dict[str, object]] = {
         "relationship": "self",
         "peer": True,
         "graph": "PageRank + Tarjan + Louvain + layers",
-        "note": "Graph algorithms (PageRank, SCC, Louvain, Fiedler) on tree-sitter ASTs fused with git history in SQLite. 136 MCP tools, 187 CLI commands. 19 Python idiom detectors (v12.7+). 54 algo detectors (12.33).",
-        "version_evaluated": "12.33",
+        "note": "Graph algorithms (PageRank, SCC, Louvain, Fiedler) on tree-sitter ASTs fused with git history in SQLite. 136 MCP tools, 187 CLI commands. 19 Python idiom detectors (v12.7+). 54 algo detectors (12.35).",
+        "version_evaluated": "12.35",
         "repo_url": "https://github.com/Cranot/roam-code",
     },
     "CKB/CodeMCP": {

{roam_code-12.33 → roam_code-12.35}/src/roam/mcp-server-card.json

@@ -2,7 +2,7 @@
   "$schema": "https://schemas.modelcontextprotocol.io/server-card/v1",
   "name": "roam-code",
   "display_name": "roam — instant codebase intelligence",
-  "version": "12.33",
+  "version": "12.35",
   "description": "Architectural sight for AI agents before they edit. Pre-indexes symbols, call graphs, dependencies, architecture layers, and git history into a local SQLite DB. 136 MCP tools, 10 resources, 5 prompts, 27 languages. 100% local, zero API keys.",
   "vendor": {
     "name": "Cranot",

{roam_code-12.33 → roam_code-12.35}/src/roam/rules/engine.py

@@ -41,64 +41,158 @@ def _load_yaml(path: Path) -> dict | None:
         return None
 
 
+def _coerce_scalar(val: str) -> object:
+    """Best-effort YAML scalar coercion: bool / int / float / quoted string."""
+    val = val.strip().strip('"').strip("'")
+    if val.lower() == "true":
+        return True
+    if val.lower() == "false":
+        return False
+    try:
+        return int(val)
+    except ValueError:
+        try:
+            return float(val)
+        except ValueError:
+            return val
+
+
 def _parse_simple_yaml(path: Path) -> dict | None:
     """Minimal YAML subset parser for rule files (no PyYAML dependency).
 
-    Handles flat key-value pairs, lists as ``[a, b]``, and nested maps
-    introduced by indented keys under a parent key.
+    Handles:
+    * flat key-value pairs
+    * inline lists ``[a, b, c]``
+    * nested maps under an indented key
+    * list-of-dicts shape introduced by ``- key: value`` items (the
+      ``rules:`` block in rules.yml is the canonical use)
+
+    12.34 (2026-05-06) — added list-of-dicts support; CI 12.33 failed
+    on Python 3.9 (PyYAML not installed) because
+    ``test_load_rules_yaml_simple`` uses that shape.
+
+    Frames track ``(indent, container, kind, parent_key)``. When we hit
+    a ``- key: value`` item and the current frame is an empty dict, we
+    promote it to a list inside the parent container at the recorded
+    ``parent_key``, then push a new dict frame for the item.
     """
     try:
         text = path.read_text(encoding="utf-8")
     except Exception:
         return None
 
+    # 12.35 (2026-05-06) — sanity-check obviously malformed YAML so callers
+    # don't get a permissive non-empty result that hides the bug. PyYAML
+    # raises YAMLError on shapes like `this is not: valid: yaml: at all: [`;
+    # the fallback should mimic that behaviour. Cheap signals: unbalanced
+    # brackets on a single line.
+    first_real_line = ""
+    for line in text.split("\n"):
+        s = line.strip()
+        if not s or s.startswith("#"):
+            continue
+        if not first_real_line:
+            first_real_line = s
+        opens = s.count("[") + s.count("{")
+        closes = s.count("]") + s.count("}")
+        if opens != closes:
+            raise ValueError(f"malformed YAML: unbalanced brackets in {path}")
+
+    # 12.35 — top-level-is-a-list detection. PyYAML returns a Python list
+    # for input that starts with `- `; the loader downstream surfaces a
+    # "must be a mapping" warning because rules.yml requires a dict at
+    # the root. Without this, a top-level-list file silently returns {}
+    # and no warning ever surfaces.
+    if first_real_line.startswith("- "):
+        items: list[object] = []
+        for line in text.split("\n"):
+            s = line.strip()
+            if not s or s.startswith("#"):
+                continue
+            if s.startswith("- "):
+                items.append(_coerce_scalar(s[2:].strip()))
+        # Cast to dict-shaped return is wrong — return list explicitly so
+        # callers can detect "not a dict at top level". Using a list-typed
+        # return requires a typing-loose return; the function annotation is
+        # `dict | None` but Python is dynamic — return the list. Callers
+        # downstream check `isinstance(data, dict)`.
+        return items  # type: ignore[return-value]
+
     result: dict = {}
-    stack: list[tuple[int, dict]] = [(0, result)]
+    # Frame: (indent, container, kind, parent_dict, parent_key)
+    # The root frame has parent_dict=None / parent_key=None.
+    stack: list[tuple[int, object, str, object, object]] = [(0, result, "dict", None, None)]
 
-    for line in text.split("\n"):
-        stripped = line.strip()
+    for raw in text.split("\n"):
+        stripped = raw.strip()
         if not stripped or stripped.startswith("#"):
             continue
 
-        indent = len(line) - len(line.lstrip())
+        indent = len(raw) - len(raw.lstrip())
 
-        # Pop stack to matching indent
         while len(stack) > 1 and indent < stack[-1][0]:
             stack.pop()
 
+        if stripped.startswith("- "):
+            after_dash = stripped[2:].strip()
+            top = stack[-1]
+            top_indent, top_container, top_kind, top_parent, top_pkey = top
+
+            # If current frame is an empty dict that was opened by a parent
+            # `key:` (no value), promote it to a list and replace it in the
+            # parent. This is how `rules:\n  - id: ...` becomes
+            # `{"rules": [{"id": ...}]}` instead of `{"rules": {"- id": ...}}`.
+            if (
+                top_kind == "dict"
+                and isinstance(top_container, dict)
+                and not top_container
+                and top_parent is not None
+                and top_pkey is not None
+            ):
+                new_list: list = []
+                top_parent[top_pkey] = new_list
+                stack[-1] = (top_indent, new_list, "list", top_parent, top_pkey)
+                top_container = new_list
+                top_kind = "list"
+
+            if top_kind == "list" and isinstance(top_container, list):
+                if ":" in after_dash:
+                    new_item: dict = {}
+                    top_container.append(new_item)
+                    key, _, val = after_dash.partition(":")
+                    key = key.strip()
+                    if val.strip():
+                        new_item[key] = _coerce_scalar(val)
+                    else:
+                        new_item[key] = {}
+                    # Push the new item dict so subsequent same-indent keys
+                    # populate it. Indent of children = indent + 2.
+                    stack.append((indent + 2, new_item, "dict", top_container, len(top_container) - 1))
+                else:
+                    top_container.append(_coerce_scalar(after_dash))
+            continue
+
         if ":" not in stripped:
             continue
 
         key, _, val = stripped.partition(":")
         key = key.strip()
+        val_raw = val
         val = val.strip()
 
-        current = stack[-1][1]
+        _i, container, kind, _pp, _pk = stack[-1]
+        if kind != "dict" or not isinstance(container, dict):
+            continue
 
         if not val:
-            # Start a nested dict
             child: dict = {}
-            current[key] = child
-            stack.append((indent + 2, child))
+            container[key] = child
+            stack.append((indent + 2, child, "dict", container, key))
         elif val.startswith("[") and val.endswith("]"):
-            # Inline list
             items = [v.strip().strip('"').strip("'") for v in val[1:-1].split(",") if v.strip()]
-            current[key] = items
+            container[key] = items
         else:
-            val = val.strip('"').strip("'")
-            if val.lower() == "true":
-                parsed_val: object = True
-            elif val.lower() == "false":
-                parsed_val = False
-            else:
-                try:
-                    parsed_val = int(val)
-                except ValueError:
-                    try:
-                        parsed_val = float(val)
-                    except ValueError:
-                        parsed_val = val
-            current[key] = parsed_val
+            container[key] = _coerce_scalar(val_raw)
 
     return result if result else None
 

{roam_code-12.33 → roam_code-12.35}/src/roam_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roam-code
-Version: 12.33
+Version: 12.35
 Summary: Instant codebase comprehension for AI coding agents
 Author: CosmoHac
 License-Expression: Apache-2.0