Simplify: SERVICE pre-filter, shared row helpers, tidy walk

- _uses_service short-circuits when the query has no 'service' substring,
  skipping a ~1ms SPARQL parse on the common (no-federation) path — safe
  since SERVICE is the only federation spelling; string literals still fall
  through to the algebra walk. Walk rewritten as an early-return any().
- extract the JSON row shapes that cli and mcp_server both emit: propose.
  proposal_row() and Relation.as_row() — one wire contract for lokf propose
  --json / lokf vocab --json and the MCP propose_relations / get_vocabulary
  tools, so the two surfaces can't drift.

Kept (per /simplify): FORMATS aliases (helpful spellings, listed in errors),
inline server HTML (fine for one page), the query-form dispatch per surface
(renders to different output types). 118 tests pass.

Author: nicholsn

src/lokf/cli.py

@@ -142,7 +142,7 @@ def propose(
 ) -> None:
     """Propose typed relations from markdown links in concept bodies."""
     from lokf.model import load_bundle
-    from lokf.propose import apply
+    from lokf.propose import apply, proposal_row
     from lokf.propose import propose as propose_relations
     from lokf.schema import vocabulary
 
@@ -161,20 +161,8 @@ def propose(
     applied_ids = {id(p) for p in applied}
 
     if json_:
-        rows = []
-        for p in proposals:
-            row = {
-                "source": p.source.concept_id,
-                "link_text": p.link.text,
-                "target": p.target_iri,
-                "predicate": p.relation.name,
-                "curie": p.relation.curie,
-                "confidence": round(p.confidence, 2),
-                "rationale": p.rationale,
-            }
-            if apply_:
-                row["applied"] = id(p) in applied_ids
-            rows.append(row)
+        ids = applied_ids if apply_ else None
+        rows = [proposal_row(p, ids) for p in proposals]
         typer.echo(json.dumps(rows, indent=2))
         return
 
@@ -220,21 +208,7 @@ def vocab(
     v = vocabulary()
     relations = sorted(v.relation_types.values(), key=lambda r: r.name)
     if json_:
-        typer.echo(
-            json.dumps(
-                [
-                    {
-                        "name": r.name,
-                        "curie": r.curie,
-                        "uri": r.uri,
-                        "frontmatter_key": r.is_slot,
-                        "description": r.description,
-                    }
-                    for r in relations
-                ],
-                indent=2,
-            )
-        )
+        typer.echo(json.dumps([r.as_row() for r in relations], indent=2))
         return
     name_w = max(len(r.name) for r in relations)
     curie_w = max(len(r.curie) for r in relations)

src/lokf/mcp_server.py

@@ -129,7 +129,7 @@ def propose_relations(
     """
     from lokf.model import load_bundle
     from lokf.propose import apply as apply_proposals
-    from lokf.propose import propose
+    from lokf.propose import propose, proposal_row
     from lokf.schema import vocabulary
 
     b = load_bundle(bundle)
@@ -138,26 +138,12 @@ def propose_relations(
         for p in propose(b, vocabulary())
         if p.confidence >= min_confidence
     ]
-    applied_ids: set[int] = set()
+    applied_ids: set[int] | None = None
     if apply:
         applied_ids = {
             id(p) for p in apply_proposals(proposals, min_confidence=min_confidence)
         }
-    rows = []
-    for p in proposals:
-        row = {
-            "source": p.source.concept_id,
-            "link_text": p.link.text,
-            "target": p.target_iri,
-            "predicate": p.relation.name,
-            "curie": p.relation.curie,
-            "confidence": round(p.confidence, 2),
-            "rationale": p.rationale,
-        }
-        if apply:
-            row["applied"] = id(p) in applied_ids
-        rows.append(row)
-    return rows
+    return [proposal_row(p, applied_ids) for p in proposals]
 
 
 @server.tool()
@@ -175,16 +161,7 @@ def get_vocabulary() -> dict:
     relations = sorted(v.relation_types.values(), key=lambda r: r.name)
     return {
         "classes": dict(v.classes),
-        "relations": [
-            {
-                "name": r.name,
-                "curie": r.curie,
-                "uri": r.uri,
-                "frontmatter_key": r.is_slot,
-                "description": r.description,
-            }
-            for r in relations
-        ],
+        "relations": [r.as_row() for r in relations],
     }
 
 

src/lokf/propose.py

@@ -255,6 +255,27 @@ def propose(
     return proposals
 
 
+def proposal_row(proposal: Proposal, applied_ids: set[int] | None = None) -> dict:
+    """A JSON-serializable row for a proposal.
+
+    Shared wire shape for ``lokf propose --json`` and the MCP
+    ``propose_relations`` tool. When *applied_ids* is given (apply mode), the
+    row gains an ``applied`` flag; in dry-run mode it is omitted.
+    """
+    row = {
+        "source": proposal.source.concept_id,
+        "link_text": proposal.link.text,
+        "target": proposal.target_iri,
+        "predicate": proposal.relation.name,
+        "curie": proposal.relation.curie,
+        "confidence": round(proposal.confidence, 2),
+        "rationale": proposal.rationale,
+    }
+    if applied_ids is not None:
+        row["applied"] = id(proposal) in applied_ids
+    return row
+
+
 def _rt_yaml():
     from ruamel.yaml import YAML
 

src/lokf/schema.py

@@ -88,6 +88,16 @@ class Relation:
     is_slot: bool  # True: usable as a frontmatter key; False: via `relations:`
     domains: frozenset[str] = frozenset()  # classes declaring the slot; "Concept" = all
 
+    def as_row(self) -> dict:
+        """A JSON-serializable row (the ``lokf vocab --json`` / MCP shape)."""
+        return {
+            "name": self.name,
+            "curie": self.curie,
+            "uri": self.uri,
+            "frontmatter_key": self.is_slot,
+            "description": self.description,
+        }
+
 
 class Vocabulary:
     """The LOKF vocabulary derived from the LinkML schema."""

src/lokf/store.py

@@ -55,30 +55,31 @@ def _uses_service(sparql: str) -> bool:
     not trip it. If rdflib cannot parse the query, returns False and lets the
     engine reject it — this only gates the federation vector, not validity.
     """
+    # SERVICE is the only spelling of the federation keyword, so a query with
+    # no "service" substring cannot contain one — skip the ~1ms parse. (A
+    # "service" inside a string literal still falls through to the algebra
+    # walk, which correctly ignores it.)
+    if "service" not in sparql.lower():
+        return False
+
     from rdflib.plugins.sparql import prepareQuery
     from rdflib.plugins.sparql.parserutils import CompValue
 
     try:
         algebra = prepareQuery(sparql).algebra
     except Exception:  # noqa: BLE001 — parse failures fall through to the engine
         return False
-    found = []
-
-    def walk(node):
-        if isinstance(node, CompValue):
-            if node.name == "ServiceGraphPattern":
-                found.append(True)
-            for v in node.values():
-                walk(v)
-        elif isinstance(node, (list, tuple, set)):
-            for v in node:
-                walk(v)
-        elif isinstance(node, dict):
-            for v in node.values():
-                walk(v)
-
-    walk(algebra)
-    return bool(found)
+
+    def walk(node) -> bool:
+        if isinstance(node, CompValue):  # note: CompValue is itself a dict
+            return node.name == "ServiceGraphPattern" or any(map(walk, node.values()))
+        if isinstance(node, (list, tuple, set)):
+            return any(map(walk, node))
+        if isinstance(node, dict):
+            return any(map(walk, node.values()))
+        return False
+
+    return walk(algebra)
 
 
 class GraphStore: