Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

revert: remove the synthesized domain graph (domain/flow/step) (#578)

Raghav Chamadiya933f27482b6c
diff --git a/packages/core/alembic/versions/0034_domain_graph.py b/packages/core/alembic/versions/0034_domain_graph.py
deleted file mode 100644
index f44e4d08e..000000000
--- a/packages/core/alembic/versions/0034_domain_graph.py
+++ /dev/null
@@ -1,92 +0,0 @@
-"""Domain graph tables: behavior-oriented Domain / Flow / Step nodes + edges.
-
-Adds the persistence for the synthesized domain graph (the artifact that
-answers "what does the system do?"), mirroring the structural graph's
-discriminated single-table-of-nodes + typed-edges shape:
-
-- ``domain_graph_nodes`` holds Domain, Flow, and Step rows (``kind``), with the
- renderable wiki page content (``page_title`` / ``page_content``) stored
- alongside the structural fields on domain/flow rows.
-- ``domain_graph_edges`` holds ``contains_flow`` / ``flow_step`` /
- ``cross_domain`` edges.
-
-Additive and self-contained; no existing table is touched.
-
-Revision ID: 0034
-Revises: 0033
-Create Date: 2026-06-23
-"""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers
-revision: str = "0034"
-down_revision: str | None = "0033"
-branch_labels: str | Sequence[str] | None = None
-depends_on: str | Sequence[str] | None = None
-
-
-def upgrade() -> None:
- op.create_table(
- "domain_graph_nodes",
- sa.Column("id", sa.String(32), primary_key=True),
- sa.Column(
- "repository_id",
- sa.String(32),
- sa.ForeignKey("repositories.id", ondelete="CASCADE"),
- nullable=False,
- ),
- sa.Column("node_id", sa.Text, nullable=False),
- sa.Column("kind", sa.String(16), nullable=False),
- sa.Column("name", sa.Text, nullable=False, server_default=""),
- sa.Column("summary", sa.Text, nullable=False, server_default=""),
- sa.Column("parent_id", sa.Text, nullable=True),
- sa.Column("step_order", sa.Integer, nullable=True),
- sa.Column("implements_json", sa.Text, nullable=False, server_default="[]"),
- sa.Column("display_order", sa.Integer, nullable=False, server_default="0"),
- sa.Column("page_title", sa.Text, nullable=False, server_default=""),
- sa.Column("page_content", sa.Text, nullable=False, server_default=""),
- sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
- sa.UniqueConstraint("repository_id", "node_id", name="uq_domain_graph_node"),
- )
- op.create_index(
- "ix_domain_graph_nodes_repo", "domain_graph_nodes", ["repository_id"]
- )
-
- op.create_table(
- "domain_graph_edges",
- sa.Column("id", sa.String(32), primary_key=True),
- sa.Column(
- "repository_id",
- sa.String(32),
- sa.ForeignKey("repositories.id", ondelete="CASCADE"),
- nullable=False,
- ),
- sa.Column("source_node_id", sa.Text, nullable=False),
- sa.Column("target_node_id", sa.Text, nullable=False),
- sa.Column("edge_type", sa.String(32), nullable=False),
- sa.Column("weight", sa.Float, nullable=False, server_default="0"),
- sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
- sa.UniqueConstraint(
- "repository_id",
- "source_node_id",
- "target_node_id",
- "edge_type",
- name="uq_domain_graph_edge",
- ),
- )
- op.create_index(
- "ix_domain_graph_edges_repo", "domain_graph_edges", ["repository_id"]
- )
-
-
-def downgrade() -> None:
- op.drop_index("ix_domain_graph_edges_repo", table_name="domain_graph_edges")
- op.drop_table("domain_graph_edges")
- op.drop_index("ix_domain_graph_nodes_repo", table_name="domain_graph_nodes")
- op.drop_table("domain_graph_nodes")
diff --git a/packages/core/src/repowise/core/analysis/knowledge_graph.py b/packages/core/src/repowise/core/analysis/knowledge_graph.py
index 252685892..573412076 100644
--- a/packages/core/src/repowise/core/analysis/knowledge_graph.py
+++ b/packages/core/src/repowise/core/analysis/knowledge_graph.py
@@ -30,11 +30,6 @@ class KnowledgeGraphResult:
# populates this; empty means the key is omitted from ``to_dict`` so the
# flag-off artifact stays byte-identical.
modules: list[dict] = field(default_factory=list)
- # Behavior-oriented domain graph (Domain -> Flow -> Step), synthesized by the
- # generation pipeline after pages exist. Serialized as a ``DomainGraph`` dict
- # (see ``core.generation.domain_graph``); empty/omitted on the deterministic
- # skeleton so the uncurated export's byte shape is unchanged.
- domain_graph: dict = field(default_factory=dict)
fingerprint: str = ""
def to_dict(self) -> dict:
@@ -77,11 +72,6 @@ class KnowledgeGraphResult:
out["modules"] = [
{**m, "nodeIds": sorted(m.get("nodeIds", []))} for m in self.modules
]
- if self.domain_graph:
- # Additive key: present only when the domain graph was synthesized,
- # so the skeleton/uncurated export's byte shape is unchanged. Lets
- # the graph round-trip through ``knowledge-graph.json`` for caching.
- out["domain_graph"] = self.domain_graph
return out
@classmethod
@@ -98,7 +88,6 @@ class KnowledgeGraphResult:
layers=data.get("layers", []),
tour=data.get("tour", []),
modules=data.get("modules", []),
- domain_graph=data.get("domain_graph", {}),
)
diff --git a/packages/core/src/repowise/core/generation/domain_graph/__init__.py b/packages/core/src/repowise/core/generation/domain_graph/__init__.py
deleted file mode 100644
index f21d0b5fa..000000000
--- a/packages/core/src/repowise/core/generation/domain_graph/__init__.py
+++ /dev/null
@@ -1,31 +0,0 @@
-"""Behavior-oriented domain graph (Domain -> Flow -> Step).
-
-A synthesized artifact layered on top of the structural knowledge graph that
-answers "what does this system do?". Built after wiki pages exist, from layers
-+ file summaries + the heaviest import edges (not raw source), with a fixed,
-bounded LLM budget. See :mod:`.synthesis` for the orchestration and
-:mod:`.models` for the in-memory shape.
-"""
-
-from __future__ import annotations
-
-from .models import (
- CrossDomainEdge,
- DomainGraph,
- DomainNode,
- FlowNode,
- StepNode,
-)
-from .persistence_map import flatten_edges, flatten_nodes
-from .synthesis import synthesize_domain_graph
-
-__all__ = [
- "CrossDomainEdge",
- "DomainGraph",
- "DomainNode",
- "FlowNode",
- "StepNode",
- "flatten_edges",
- "flatten_nodes",
- "synthesize_domain_graph",
-]
diff --git a/packages/core/src/repowise/core/generation/domain_graph/cache.py b/packages/core/src/repowise/core/generation/domain_graph/cache.py
deleted file mode 100644
index 329882d47..000000000
--- a/packages/core/src/repowise/core/generation/domain_graph/cache.py
+++ /dev/null
@@ -1,57 +0,0 @@
-"""Per-domain structural fingerprint + reuse (mirrors page-cache behaviour).
-
-A domain's flows/steps only need re-synthesizing when its member set changes
-structurally. The fingerprint hashes the member node ids together with their
-best summaries (which themselves change only when the underlying source does),
-so an unchanged domain can reuse the prior run's flows without an LLM call.
-Pure - no DB, no LLM.
-"""
-
-from __future__ import annotations
-
-import hashlib
-
-from .models import DomainGraph, DomainNode, FlowNode
-
-
-def domain_fingerprint(
- member_node_ids: list[str],
- summary_by_node_id: dict[str, str],
- internal_edges: list[tuple[str, str]] = (),
-) -> str:
- """Stable hash over the members (id + summary) and their internal coupling.
-
- Folding the internal import edges in means a coupling change among
- otherwise-unchanged member files still invalidates the cache, so reused
- flows can never reflect stale structure.
- """
- hasher = hashlib.sha256()
- for nid in sorted(member_node_ids):
- hasher.update(nid.encode("utf-8"))
- hasher.update(b"\x00")
- hasher.update((summary_by_node_id.get(nid, "")).encode("utf-8"))
- hasher.update(b"\x01")
- hasher.update(b"\x02")
- for src, tgt in sorted(internal_edges):
- hasher.update(src.encode("utf-8"))
- hasher.update(b"\x00")
- hasher.update(tgt.encode("utf-8"))
- hasher.update(b"\x01")
- return hasher.hexdigest()
-
-
-def reuse_flows(
- prior: DomainGraph | None,
- domain: DomainNode,
-) -> list[FlowNode] | None:
- """Return the prior run's flows for *domain* when its fingerprint matches.
-
- Matched by slug + fingerprint; ``None`` means "re-synthesize". A prior
- domain with an empty fingerprint never matches (forces a refresh).
- """
- if prior is None or not domain.fingerprint:
- return None
- for prev in prior.domains:
- if prev.slug == domain.slug and prev.fingerprint == domain.fingerprint and prev.flows:
- return [FlowNode.from_dict(f.to_dict()) for f in prev.flows]
- return None
diff --git a/packages/core/src/repowise/core/generation/domain_graph/context.py b/packages/core/src/repowise/core/generation/domain_graph/context.py
deleted file mode 100644
index 34cd3af06..000000000
--- a/packages/core/src/repowise/core/generation/domain_graph/context.py
+++ /dev/null
@@ -1,196 +0,0 @@
-"""(a) Context assembly for domain synthesis.
-
-Pure functions that gather the bounded context the LLM prompts need, drawn from
-the already-generated structural artifacts (enriched layers, file node summaries,
-the heaviest import edges) - never from raw source. No DB, no LLM, no I/O, so
-every function here is unit-testable against small fixture dicts.
-
-Two contexts are assembled:
-
-* a per-layer **cluster** summary feeding the domain-naming prompt, and
-* a per-domain **member** view (ranked files + summaries + internal import
- edges) feeding the per-domain flow/step prompt.
-
-Cross-domain dependency edges are derived structurally from the import edges
-that cross a domain boundary.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-
-from .models import CrossDomainEdge, DomainNode
-
-
-@dataclass
-class LayerCluster:
- """Compact view of one structural layer for the naming prompt."""
-
- layer_id: str
- name: str
- description: str
- file_count: int
- top_files: list[str] = field(default_factory=list)
-
-
-@dataclass
-class FileContext:
- """A member file plus its best available one-line summary."""
-
- node_id: str # "file:<path>"
- path: str
- summary: str = ""
-
-
-def _is_file_node(node: dict) -> bool:
- nid = node.get("id")
- return isinstance(nid, str) and nid.startswith("file:")
-
-
-def _node_path(node: dict) -> str:
- return node.get("filePath") or str(node.get("id", "")).removeprefix("file:")
-
-
-def _best_summary(node: dict, page_summaries: dict[str, str]) -> str:
- """Prefer a rich wiki-page summary; fall back to the node's own summary."""
- path = _node_path(node)
- return page_summaries.get(path) or str(node.get("summary") or "")
-
-
-def file_nodes_by_id(nodes: list[dict]) -> dict[str, dict]:
- return {n["id"]: n for n in nodes if _is_file_node(n) and n.get("id")}
-
-
-def _rank(node: dict) -> float:
- try:
- return float(node.get("pagerank") or 0.0)
- except (TypeError, ValueError):
- return 0.0
-
-
-def build_layer_clusters(
- layers: list[dict],
- nodes: list[dict],
- max_files: int = 12,
-) -> list[LayerCluster]:
- """One :class:`LayerCluster` per structural layer, ranked top files first.
-
- Empty layers (no file members) are dropped - a domain can only be named
- from a real cluster.
- """
- by_id = file_nodes_by_id(nodes)
- clusters: list[LayerCluster] = []
- for layer in layers:
- member_ids = [nid for nid in layer.get("nodeIds", []) if nid in by_id]
- if not member_ids:
- continue
- ranked = sorted(member_ids, key=lambda nid: _rank(by_id[nid]), reverse=True)
- top = [_node_path(by_id[nid]) for nid in ranked[:max_files]]
- clusters.append(
- LayerCluster(
- layer_id=str(layer.get("id", "")),
- name=str(layer.get("name", "")),
- description=str(layer.get("description", "")),
- file_count=len(member_ids),
- top_files=top,
- )
- )
- return clusters
-
-
-def member_node_ids(layer_ids: list[str], layers: list[dict], nodes: list[dict]) -> list[str]:
- """Union of the file node ids belonging to *layer_ids* (deduped, sorted)."""
- by_id = file_nodes_by_id(nodes)
- wanted = set(layer_ids)
- out: set[str] = set()
- for layer in layers:
- if str(layer.get("id", "")) in wanted:
- out.update(nid for nid in layer.get("nodeIds", []) if nid in by_id)
- return sorted(out)
-
-
-def build_member_context(
- domain: DomainNode,
- nodes: list[dict],
- page_summaries: dict[str, str],
- max_files: int = 25,
-) -> list[FileContext]:
- """Ranked member files with their best summaries, for the flow prompt."""
- by_id = file_nodes_by_id(nodes)
- members = [nid for nid in domain.member_node_ids if nid in by_id]
- ranked = sorted(members, key=lambda nid: _rank(by_id[nid]), reverse=True)
- out: list[FileContext] = []
- for nid in ranked[:max_files]:
- node = by_id[nid]
- out.append(
- FileContext(
- node_id=nid,
- path=_node_path(node),
- summary=_best_summary(node, page_summaries),
- )
- )
- return out
-
-
-def heaviest_internal_edges(
- member_node_ids_set: set[str],
- edges: list[dict],
- top: int = 15,
-) -> list[tuple[str, str]]:
- """The highest-weight import edges with both endpoints inside the domain.
-
- Returns ``(source_path, target_path)`` pairs so the prompt can show real
- "A is used by B" coupling without leaking node-id noise.
- """
- scored: list[tuple[float, str, str]] = []
- for edge in edges:
- src = edge.get("source", "")
- tgt = edge.get("target", "")
- if src in member_node_ids_set and tgt in member_node_ids_set:
- weight = float(edge.get("weight", 1) or 1)
- scored.append((weight, src, tgt))
- scored.sort(key=lambda t: (-t[0], t[1], t[2]))
- return [
- (src.removeprefix("file:"), tgt.removeprefix("file:")) for _, src, tgt in scored[:top]
- ]
-
-
-def internal_edge_ids(
- member_node_ids_set: set[str],
- edges: list[dict],
-) -> list[tuple[str, str]]:
- """All ``(source, target)`` node-id pairs with both ends inside the member
- set, sorted. Feeds the domain fingerprint so a coupling change among
- otherwise-unchanged members still forces a re-synthesis."""
- pairs = {
- (edge.get("source", ""), edge.get("target", ""))
- for edge in edges
- if edge.get("source", "") in member_node_ids_set
- and edge.get("target", "") in member_node_ids_set
- }
- return sorted(pairs)
-
-
-def derive_cross_domain_edges(
- domains: list[DomainNode],
- edges: list[dict],
-) -> list[CrossDomainEdge]:
- """Aggregate import edges that cross a domain boundary into domain->domain
- dependency edges weighted by the count of crossing imports."""
- domain_of: dict[str, str] = {}
- for domain in domains:
- for nid in domain.member_node_ids:
- domain_of[nid] = domain.id
-
- counts: dict[tuple[str, str], int] = {}
- for edge in edges:
- src_domain = domain_of.get(edge.get("source", ""))
- tgt_domain = domain_of.get(edge.get("target", ""))
- if src_domain and tgt_domain and src_domain != tgt_domain:
- key = (src_domain, tgt_domain)
- counts[key] = counts.get(key, 0) + 1
-
- return [
- CrossDomainEdge(source=src, target=tgt, weight=weight)
- for (src, tgt), weight in sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))
- ]
diff --git a/packages/core/src/repowise/core/generation/domain_graph/models.py b/packages/core/src/repowise/core/generation/domain_graph/models.py
deleted file mode 100644
index 4f7b96c78..000000000
--- a/packages/core/src/repowise/core/generation/domain_graph/models.py
+++ /dev/null
@@ -1,180 +0,0 @@
-"""In-memory dataclasses for the behavior-oriented domain graph.
-
-The structural knowledge graph answers "what is the code?"; the domain graph
-answers "what does the system do?". It has three levels:
-
-* :class:`DomainNode` - a capability / bounded context (e.g. "Indexing
- Pipeline"), backed by one or more structural layers.
-* :class:`FlowNode` - a process within a domain (e.g. "Index a repository
- from scratch").
-* :class:`StepNode` - an ordered stage in a flow, mapped to the concrete
- file/symbol node ids that implement it.
-
-These are pure data with ``to_dict`` / ``from_dict`` round-trips so the graph
-can travel through the ``knowledge-graph.json`` artifact and be validated by the
-reviewer without a DB or an LLM. Flattening to persistable nodes/edges lives in
-:mod:`.persistence_map`; rendering to wiki page content lives in :mod:`.render`.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-
-# Domain-graph edge types (mirrors the structural graph's typed-edge model).
-EDGE_CONTAINS_FLOW = "contains_flow"
-EDGE_FLOW_STEP = "flow_step"
-EDGE_CROSS_DOMAIN = "cross_domain"
-
-
-@dataclass
-class StepNode:
- """One ordered stage of a flow, mapped to real implementing node ids."""
-
- order: int
- name: str
- summary: str = ""
- # Real file/symbol node ids ("file:<path>") that implement this step.
- # Always validated against the structural graph before persistence.
- implements: list[str] = field(default_factory=list)
-
- def id(self, flow_id: str) -> str:
- return f"step:{flow_id.removeprefix('flow:')}/{self.order}"
-
- def to_dict(self) -> dict:
- return {
- "order": self.order,
- "name": self.name,
- "summary": self.summary,
- "implements": list(self.implements),
- }
-
- @classmethod
- def from_dict(cls, data: dict) -> StepNode:
- return cls(
- order=int(data.get("order", 0)),
- name=str(data.get("name", "")),
- summary=str(data.get("summary", "")),
- implements=list(data.get("implements", [])),
- )
-
-
-@dataclass
-class FlowNode:
- """A process within a domain - an ordered sequence of steps."""
-
- slug: str
- name: str
- summary: str = ""
- steps: list[StepNode] = field(default_factory=list)
-
- def id(self, domain_id: str) -> str:
- return f"flow:{domain_id.removeprefix('domain:')}/{self.slug}"
-
- def to_dict(self) -> dict:
- return {
- "slug": self.slug,
- "name": self.name,
- "summary": self.summary,
- "steps": [s.to_dict() for s in self.steps],
- }
-
- @classmethod
- def from_dict(cls, data: dict) -> FlowNode:
- return cls(
- slug=str(data.get("slug", "")),
- name=str(data.get("name", "")),
- summary=str(data.get("summary", "")),
- steps=[StepNode.from_dict(s) for s in data.get("steps", [])],
- )
-
-
-@dataclass
-class DomainNode:
- """A capability / bounded context backed by structural layers."""
-
- slug: str
- name: str
- summary: str = ""
- # Structural layer ids this domain is built from.
- member_layer_ids: list[str] = field(default_factory=list)
- # Union of the member layers' file node ids ("file:<path>"). The validation
- # surface flows/steps may map into.
- member_node_ids: list[str] = field(default_factory=list)
- flows: list[FlowNode] = field(default_factory=list)
- # Structural fingerprint of the member set; lets a re-index reuse an
- # unchanged domain's flows/steps without a fresh LLM call.
- fingerprint: str = ""
-
- @property
- def id(self) -> str:
- return f"domain:{self.slug}"
-
- def to_dict(self) -> dict:
- return {
- "slug": self.slug,
- "name": self.name,
- "summary": self.summary,
- "member_layer_ids": list(self.member_layer_ids),
- "member_node_ids": list(self.member_node_ids),
- "flows": [f.to_dict() for f in self.flows],
- "fingerprint": self.fingerprint,
- }
-
- @classmethod
- def from_dict(cls, data: dict) -> DomainNode:
- return cls(
- slug=str(data.get("slug", "")),
- name=str(data.get("name", "")),
- summary=str(data.get("summary", "")),
- member_layer_ids=list(data.get("member_layer_ids", [])),
- member_node_ids=list(data.get("member_node_ids", [])),
- flows=[FlowNode.from_dict(f) for f in data.get("flows", [])],
- fingerprint=str(data.get("fingerprint", "")),
- )
-
-
-@dataclass
-class CrossDomainEdge:
- """A dependency from one domain to another, weighted by import volume."""
-
- source: str # "domain:<slug>"
- target: str # "domain:<slug>"
- weight: int = 0
-
- def to_dict(self) -> dict:
- return {"source": self.source, "target": self.target, "weight": self.weight}
-
- @classmethod
- def from_dict(cls, data: dict) -> CrossDomainEdge:
- return cls(
- source=str(data.get("source", "")),
- target=str(data.get("target", "")),
- weight=int(data.get("weight", 0)),
- )
-
-
-@dataclass
-class DomainGraph:
- """The full behavior-oriented graph: domains, their flows/steps, and the
- cross-domain dependency edges between them."""
-
- domains: list[DomainNode] = field(default_factory=list)
- cross_domain: list[CrossDomainEdge] = field(default_factory=list)
-
- def is_empty(self) -> bool:
- return not self.domains
-
- def to_dict(self) -> dict:
- return {
- "domains": [d.to_dict() for d in self.domains],
- "cross_domain": [e.to_dict() for e in self.cross_domain],
- }
-
- @classmethod
- def from_dict(cls, data: dict) -> DomainGraph:
- if not isinstance(data, dict):
- return cls()
- return cls(
- domains=[DomainNode.from_dict(d) for d in data.get("domains", [])],
- cross_domain=[CrossDomainEdge.from_dict(e) for e in data.get("cross_domain", [])],
- )
diff --git a/packages/core/src/repowise/core/generation/domain_graph/parsing.py b/packages/core/src/repowise/core/generation/domain_graph/parsing.py
deleted file mode 100644
index 4cc193385..000000000
--- a/packages/core/src/repowise/core/generation/domain_graph/parsing.py
+++ /dev/null
@@ -1,151 +0,0 @@
-"""(c) Response parsing + node-id resolution/validation.
-
-Pure functions that turn raw LLM JSON into validated :mod:`.models` objects.
-The load-bearing guarantee here is **no hallucinated membership**: a domain may
-only claim layer ids that were offered, and a step may only implement member
-file paths that exist. Unknown ids are dropped (not trusted), empty steps and
-flows are pruned, and step orders are renumbered contiguously. Everything is
-testable with fixture strings - no LLM, no DB.
-"""
-
-from __future__ import annotations
-
-import json
-
-import structlog
-
-from .models import DomainNode, FlowNode, StepNode
-
-logger = structlog.get_logger(__name__)
-
-
-def parse_json(content: str) -> dict | None:
- """Extract a JSON object from an LLM response, tolerating code fences."""
- content = (content or "").strip()
- if content.startswith("```"):
- content = "\n".join(
- line for line in content.split("\n") if not line.strip().startswith("```")
- )
- try:
- return json.loads(content)
- except json.JSONDecodeError:
- start = content.find("{")
- end = content.rfind("}") + 1
- if start >= 0 and end > start:
- try:
- return json.loads(content[start:end])
- except json.JSONDecodeError:
- return None
- return None
-
-
-def _slugify(value: str, fallback: str) -> str:
- cleaned = "".join(c if c.isalnum() else "-" for c in value.lower())
- cleaned = "-".join(part for part in cleaned.split("-") if part)
- return cleaned or fallback
-
-
-def parse_domains(content: str, valid_layer_ids: set[str]) -> list[DomainNode]:
- """Parse the domain-naming response into domains with validated membership.
-
- A layer is assigned to the first domain that claims it (one domain per
- cluster). Domains left with no valid layer are dropped - a domain must be
- grounded in a real cluster. ``member_node_ids`` is filled in later by the
- caller once the layer->file mapping is known.
- """
- parsed = parse_json(content)
- if not parsed or not isinstance(parsed.get("domains"), list):
- return []
-
- domains: list[DomainNode] = []
- claimed: set[str] = set()
- seen_slugs: set[str] = set()
- rejected = 0
- for i, item in enumerate(parsed["domains"]):
- if not isinstance(item, dict):
- continue
- members: list[str] = []
- for lid in item.get("member_layer_ids", []):
- if lid in valid_layer_ids and lid not in claimed:
- members.append(lid)
- claimed.add(lid)
- elif lid not in valid_layer_ids:
- rejected += 1
- if not members:
- continue
- name = str(item.get("name", "")).strip() or f"Domain {i + 1}"
- slug = _slugify(str(item.get("slug", "")) or name, f"domain-{i + 1}")
- if slug in seen_slugs:
- slug = f"{slug}-{i + 1}"
- seen_slugs.add(slug)
- domains.append(
- DomainNode(
- slug=slug,
- name=name,
- summary=str(item.get("summary", "")).strip(),
- member_layer_ids=members,
- )
- )
- if rejected:
- logger.warning("domain_graph_rejected_unknown_layers", count=rejected)
- return domains
-
-
-def resolve_flows(content: str, member_node_ids: set[str]) -> list[FlowNode]:
- """Parse the flow response, keeping only steps that implement real members.
-
- *member_node_ids* are the domain's file node ids ("file:<path>"). Each
- step's ``implements`` paths are normalized to that form and filtered to the
- member set; a step with no surviving member is dropped, a flow with no
- surviving step is dropped, and step orders are renumbered 1..N.
- """
- parsed = parse_json(content)
- if not parsed or not isinstance(parsed.get("flows"), list):
- return []
-
- flows: list[FlowNode] = []
- seen_slugs: set[str] = set()
- rejected = 0
- for i, raw_flow in enumerate(parsed["flows"]):
- if not isinstance(raw_flow, dict):
- continue
- steps: list[StepNode] = []
- for raw_step in raw_flow.get("steps", []):
- if not isinstance(raw_step, dict):
- continue
- implements: list[str] = []
- for ref in raw_step.get("implements", []):
- nid = ref if str(ref).startswith("file:") else f"file:{ref}"
- if nid in member_node_ids:
- if nid not in implements:
- implements.append(nid)
- else:
- rejected += 1
- if not implements:
- continue
- steps.append(
- StepNode(
- order=len(steps) + 1,
- name=str(raw_step.get("name", "")).strip() or f"Step {len(steps) + 1}",
- summary=str(raw_step.get("summary", "")).strip(),
- implements=implements,
- )
- )
- if not steps:
- continue
- name = str(raw_flow.get("name", "")).strip() or f"Flow {i + 1}"
- slug = _slugify(str(raw_flow.get("slug", "")) or name, f"flow-{i + 1}")
- if slug in seen_slugs:
- slug = f"{slug}-{i + 1}"
- seen_slugs.add(slug)
- flows.append(
- FlowNode(
- slug=slug,
- name=name,
- summary=str(raw_flow.get("summary", "")).strip(),
- steps=steps,
- )
- )
- if rejected:
- logger.warning("domain_graph_rejected_unknown_node_ids", count=rejected)
- return flows
diff --git a/packages/core/src/repowise/core/generation/domain_graph/persistence_map.py b/packages/core/src/repowise/core/generation/domain_graph/persistence_map.py
deleted file mode 100644
index 1efd0a755..000000000
--- a/packages/core/src/repowise/core/generation/domain_graph/persistence_map.py
+++ /dev/null
@@ -1,118 +0,0 @@
-"""(d) Persistence mapping: flatten a :class:`DomainGraph` into storable rows.
-
-Pure transform from the in-memory graph to the row dicts the CRUD layer writes
-(``domain_graph_nodes`` / ``domain_graph_edges``), with the renderable page
-content attached to domain and flow rows. Testable with fixture graphs - no DB.
-
-Node row shape::
-
- {node_id, kind, name, summary, parent_id, step_order,
- implements (list[str]), page_title, page_content, display_order}
-
-Edge row shape::
-
- {source_node_id, target_node_id, edge_type, weight}
-"""
-
-from __future__ import annotations
-
-from .models import (
- EDGE_CONTAINS_FLOW,
- EDGE_CROSS_DOMAIN,
- EDGE_FLOW_STEP,
- DomainGraph,
-)
-from .render import render_domain_page, render_flow_page
-
-
-def flatten_nodes(
- graph: DomainGraph,
- hotspot_node_ids: set[str] | None = None,
-) -> list[dict]:
- """Domain, flow, and step rows in stable, display-ordered sequence."""
- rows: list[dict] = []
- for d_order, domain in enumerate(graph.domains):
- title, _summary, content = render_domain_page(domain)
- rows.append(
- {
- "node_id": domain.id,
- "kind": "domain",
- "name": domain.name,
- "summary": domain.summary,
- "parent_id": None,
- "step_order": None,
- "implements": list(domain.member_node_ids),
- "page_title": title,
- "page_content": content,
- "display_order": d_order,
- }
- )
- for f_order, flow in enumerate(domain.flows):
- flow_id = flow.id(domain.id)
- f_title, _f_summary, f_content = render_flow_page(domain, flow, hotspot_node_ids)
- rows.append(
- {
- "node_id": flow_id,
- "kind": "flow",
- "name": flow.name,
- "summary": flow.summary,
- "parent_id": domain.id,
- "step_order": None,
- "implements": [],
- "page_title": f_title,
- "page_content": f_content,
- "display_order": f_order,
- }
- )
- for step in flow.steps:
- rows.append(
- {
- "node_id": step.id(flow_id),
- "kind": "step",
- "name": step.name,
- "summary": step.summary,
- "parent_id": flow_id,
- "step_order": step.order,
- "implements": list(step.implements),
- "page_title": "",
- "page_content": "",
- "display_order": step.order,
- }
- )
- return rows
-
-
-def flatten_edges(graph: DomainGraph) -> list[dict]:
- """contains_flow (domain->flow), flow_step (flow->step, weight=order),
- and cross_domain (domain->domain, weight=import count) edges."""
- rows: list[dict] = []
- for domain in graph.domains:
- for flow in domain.flows:
- flow_id = flow.id(domain.id)
- rows.append(
- {
- "source_node_id": domain.id,
- "target_node_id": flow_id,
- "edge_type": EDGE_CONTAINS_FLOW,
- "weight": 0.0,
- }
- )
- for step in flow.steps:
- rows.append(
- {
- "source_node_id": flow_id,
- "target_node_id": step.id(flow_id),
- "edge_type": EDGE_FLOW_STEP,
- "weight": float(step.order),
- }
- )
- for edge in graph.cross_domain:
- rows.append(
- {
- "source_node_id": edge.source,
- "target_node_id": edge.target,
- "edge_type": EDGE_CROSS_DOMAIN,
- "weight": float(edge.weight),
- }
- )
- return rows
diff --git a/packages/core/src/repowise/core/generation/domain_graph/prompts.py b/packages/core/src/repowise/core/generation/domain_graph/prompts.py
deleted file mode 100644
index 6b35e9105..000000000
--- a/packages/core/src/repowise/core/generation/domain_graph/prompts.py
+++ /dev/null
@@ -1,102 +0,0 @@
-"""(b) Prompt construction for domain synthesis.
-
-Pure string builders - no LLM, no I/O. Two prompts:
-
-* :func:`build_domain_naming_prompt` groups structural layer clusters into
- behavior-oriented capability domains. Membership is constrained to the layer
- ids actually supplied, so the model cannot invent a cluster.
-* :func:`build_flow_prompt` extracts ordered flows + steps for one domain. Each
- step's implementing files are constrained to the domain's member file paths,
- so node-id resolution can reject any hallucinated membership downstream.
-"""
-
-from __future__ import annotations
-
-from .context import FileContext, LayerCluster
-
-DOMAIN_NAMING_SYSTEM = (
- "You are a software architecture analyst. You group low-level code clusters "
- "into a small set of behavior-oriented capability domains that describe what "
- "the system *does* (e.g. 'Indexing Pipeline', 'Code Health', 'Persistence'). "
- "Output valid JSON only. No preamble, no markdown fences."
-)
-
-FLOW_EXTRACTION_SYSTEM = (
- "You are a software architecture analyst. For one capability domain you "
- "describe the key end-to-end processes (flows) it performs, each as an "
- "ordered list of steps, mapping every step to the specific files that "
- "implement it. Output valid JSON only. No preamble, no markdown fences."
-)
-
-
-def build_domain_naming_prompt(clusters: list[LayerCluster]) -> str:
- lines = [
- "Group the code clusters below into 4-10 capability domains describing "
- "what the system does. Rules:",
- "- A domain's name is behavior-oriented (a capability), not a code layer "
- "name. Keep it 1-4 words.",
- "- member_layer_ids must each be one of the cluster ids listed below, "
- "copied verbatim. Do not invent ids.",
- "- Assign each cluster to at most one domain. It is fine to leave a "
- "purely incidental cluster (docs, tooling) out.",
- "- slug is a short lowercase-kebab identifier for the domain.",
- "",
- "Clusters:",
- ]
- for c in clusters:
- lines.append(f'\n--- cluster id "{c.layer_id}" ---')
- lines.append(f"Heuristic name: {c.name}")
- if c.description:
- lines.append(f"Description: {c.description}")
- lines.append(f"File count: {c.file_count}")
- if c.top_files:
- lines.append(f"Representative files: {', '.join(c.top_files)}")
- lines.append("")
- lines.append(
- 'Respond with: {"domains": [{"slug": "...", "name": "...", '
- '"summary": "one sentence", "member_layer_ids": ["..."]}]}'
- )
- return "\n".join(lines)
-
-
-def build_flow_prompt(
- domain_name: str,
- domain_summary: str,
- members: list[FileContext],
- internal_edges: list[tuple[str, str]],
-) -> str:
- lines = [
- f'Describe the key processes (flows) of the "{domain_name}" domain.',
- ]
- if domain_summary:
- lines.append(f"Domain summary: {domain_summary}")
- lines += [
- "",
- "Rules:",
- "- Produce 1-4 flows. Each flow is a real end-to-end process in this "
- "domain (e.g. 'Index a repository from scratch').",
- "- Each flow has ordered steps starting at 1, contiguous, no gaps.",
- "- Every step's `implements` is a list of file paths chosen ONLY from "
- "the member files listed below, copied verbatim. Never invent a path.",
- "- A step maps to at least one member file. Keep summaries to one line.",
- "- slug is a short lowercase-kebab identifier for the flow.",
- "",
- "Member files (path -- summary):",
- ]
- for m in members:
- summary = m.summary.strip().replace("\n", " ")
- if len(summary) > 160:
- summary = summary[:157] + "..."
- lines.append(f"- {m.path}" + (f" -- {summary}" if summary else ""))
- if internal_edges:
- lines.append("")
- lines.append("Key internal dependencies (A is imported by B):")
- for src, tgt in internal_edges:
- lines.append(f"- {src} <- {tgt}")
- lines.append("")
- lines.append(
- 'Respond with: {"flows": [{"slug": "...", "name": "...", '
- '"summary": "one sentence", "steps": [{"order": 1, "name": "...", '
- '"summary": "one line", "implements": ["path/to/file.py"]}]}]}'
- )
- return "\n".join(lines)
diff --git a/packages/core/src/repowise/core/generation/domain_graph/render.py b/packages/core/src/repowise/core/generation/domain_graph/render.py
deleted file mode 100644
index 6dd8ed746..000000000
--- a/packages/core/src/repowise/core/generation/domain_graph/render.py
+++ /dev/null
@@ -1,58 +0,0 @@
-"""Renderable wiki page content for domains and flows (pure).
-
-Produces ``(title, summary, markdown)`` triples so the domain graph can be
-persisted as embeddable page content alongside its structural rows. No DB, no
-LLM - Phase 5 decides how to surface these; here we only render.
-"""
-
-from __future__ import annotations
-
-from .models import DomainNode, FlowNode
-
-
-def _file_link(node_id: str) -> str:
- path = node_id.removeprefix("file:")
- return f"`{path}`"
-
-
-def render_domain_page(domain: DomainNode) -> tuple[str, str, str]:
- """A domain overview page: summary + its flows with their step counts."""
- title = domain.name
- summary = domain.summary or f"The {domain.name} capability."
- lines = [f"# {title}", "", summary, ""]
- if domain.flows:
- lines.append("## Flows")
- lines.append("")
- for flow in domain.flows:
- step_word = "step" if len(flow.steps) == 1 else "steps"
- lines.append(f"- **{flow.name}** ({len(flow.steps)} {step_word})")
- if flow.summary:
- lines.append(f" - {flow.summary}")
- return title, summary, "\n".join(lines).rstrip() + "\n"
-
-
-def render_flow_page(
- domain: DomainNode,
- flow: FlowNode,
- hotspot_node_ids: set[str] | None = None,
-) -> tuple[str, str, str]:
- """A flow page: ordered steps with the files each step implements.
-
- When *hotspot_node_ids* is supplied, a step that touches a churn hotspot is
- annotated so the riskiest stage of the flow is visible at a glance.
- """
- hotspots = hotspot_node_ids or set()
- title = f"{flow.name} ({domain.name})"
- summary = flow.summary or f"How {domain.name.lower()} performs {flow.name.lower()}."
- lines = [f"# {flow.name}", "", f"_Part of the {domain.name} domain._", "", summary, ""]
- lines.append("## Steps")
- lines.append("")
- for step in flow.steps:
- risky = any(nid in hotspots for nid in step.implements)
- marker = " ⚠ hotspot" if risky else ""
- lines.append(f"{step.order}. **{step.name}**{marker}")
- if step.summary:
- lines.append(f" - {step.summary}")
- for nid in step.implements:
- lines.append(f" - {_file_link(nid)}")
- return title, summary, "\n".join(lines).rstrip() + "\n"
diff --git a/packages/core/src/repowise/core/generation/domain_graph/synthesis.py b/packages/core/src/repowise/core/generation/domain_graph/synthesis.py
deleted file mode 100644
index f5ff9f7c1..000000000
--- a/packages/core/src/repowise/core/generation/domain_graph/synthesis.py
+++ /dev/null
@@ -1,138 +0,0 @@
-"""Async orchestrator for domain-graph synthesis.
-
-Ties the pure stages together with a fixed, bounded LLM budget: one call to
-name domains, then one call per domain to extract its flows/steps (skipped for
-any domain whose structural fingerprint is unchanged from a prior run). The
-budget is a function of the (small) domain count, never the file count.
-
-Failures degrade gracefully: a failed naming call yields an empty graph, a
-failed flow call drops only that domain. The caller wires this into
-``enrich_knowledge_graph`` inside a try/except so it can never block export.
-"""
-
-from __future__ import annotations
-
-import asyncio
-from typing import Any
-
-import structlog
-
-from . import context
-from .cache import domain_fingerprint, reuse_flows
-from .models import DomainGraph, DomainNode
-from .parsing import parse_domains, resolve_flows
-from .prompts import (
- DOMAIN_NAMING_SYSTEM,
- FLOW_EXTRACTION_SYSTEM,
- build_domain_naming_prompt,
- build_flow_prompt,
-)
-
-logger = structlog.get_logger(__name__)
-
-
-async def synthesize_domain_graph(
- layers: list[dict],
- nodes: list[dict],
- edges: list[dict],
- llm_client: Any,
- *,
- page_summaries: dict[str, str] | None = None,
- prior: DomainGraph | None = None,
- reasoning: str = "auto",
-) -> DomainGraph:
- """Synthesize the behavior-oriented domain graph from structural inputs."""
- page_summaries = page_summaries or {}
- clusters = context.build_layer_clusters(layers, nodes)
- if not clusters:
- return DomainGraph()
-
- valid_layer_ids = {c.layer_id for c in clusters}
- naming_prompt = build_domain_naming_prompt(clusters)
- try:
- response = await llm_client.generate(
- DOMAIN_NAMING_SYSTEM,
- naming_prompt,
- max_tokens=2048,
- temperature=0.3,
- reasoning=reasoning,
- )
- except Exception as exc:
- logger.warning("domain_graph_naming_failed", error=str(exc))
- return DomainGraph()
-
- domains = parse_domains(response.content, valid_layer_ids)
- if not domains:
- logger.warning("domain_graph_no_domains_parsed")
- return DomainGraph()
-
- # Resolve member files + fingerprint each domain so unchanged domains can
- # reuse cached flows instead of spending an LLM call.
- summary_by_id = {
- nid: context._best_summary(node, page_summaries)
- for nid, node in context.file_nodes_by_id(nodes).items()
- }
- for domain in domains:
- domain.member_node_ids = context.member_node_ids(
- domain.member_layer_ids, layers, nodes
- )
- internal = context.internal_edge_ids(set(domain.member_node_ids), edges)
- domain.fingerprint = domain_fingerprint(
- domain.member_node_ids, summary_by_id, internal
- )
-
- await asyncio.gather(
- *(
- _fill_flows(domain, nodes, page_summaries, edges, llm_client, prior, reasoning)
- for domain in domains
- )
- )
-
- # A domain with no extractable flow is an orphan; drop it so the persisted
- # graph satisfies the reviewer's no-orphan invariant.
- surviving = [d for d in domains if d.flows]
- dropped = len(domains) - len(surviving)
- if dropped:
- logger.info("domain_graph_dropped_orphan_domains", count=dropped)
-
- cross = context.derive_cross_domain_edges(surviving, edges)
- logger.info(
- "domain_graph_synthesized",
- domains=len(surviving),
- flows=sum(len(d.flows) for d in surviving),
- cross_domain_edges=len(cross),
- )
- return DomainGraph(domains=surviving, cross_domain=cross)
-
-
-async def _fill_flows(
- domain: DomainNode,
- nodes: list[dict],
- page_summaries: dict[str, str],
- edges: list[dict],
- llm_client: Any,
- prior: DomainGraph | None,
- reasoning: str,
-) -> None:
- """Populate one domain's flows, reusing the cache or making one LLM call."""
- cached = reuse_flows(prior, domain)
- if cached is not None:
- domain.flows = cached
- logger.debug("domain_graph_flows_reused", domain=domain.slug)
- return
-
- members = context.build_member_context(domain, nodes, page_summaries)
- internal = context.heaviest_internal_edges(set(domain.member_node_ids), edges)
- prompt = build_flow_prompt(domain.name, domain.summary, members, internal)
- try:
- response = await llm_client.generate(
- FLOW_EXTRACTION_SYSTEM,
- prompt,
- max_tokens=3000,
- temperature=0.3,
- reasoning=reasoning,
- )
- except Exception as exc:
- logger.warning("domain_graph_flow_failed", domain=domain.slug, error=str(exc))
- return
- domain.flows = resolve_flows(response.content, set(domain.member_node_ids))
diff --git a/packages/core/src/repowise/core/generation/kg_reviewer/checks.py b/packages/core/src/repowise/core/generation/kg_reviewer/checks.py
index ac28d2b6d..e5afb744e 100644
--- a/packages/core/src/repowise/core/generation/kg_reviewer/checks.py
+++ b/packages/core/src/repowise/core/generation/kg_reviewer/checks.py
@@ -215,110 +215,6 @@ def check_tour_sequential(tour: list[dict]) -> list[Finding]:
return findings
-def _domains(domain_graph: dict) -> list[dict]:
- if not isinstance(domain_graph, dict):
- return []
- domains = domain_graph.get("domains")
- return domains if isinstance(domains, list) else []
-
-
-def check_no_orphan_domains(domain_graph: dict) -> list[Finding]:
- """Every domain has at least one flow.
-
- CRITICAL: a domain with no flows carries no behavior (an orphan that should
- have been dropped during synthesis).
- """
- findings: list[Finding] = []
- for domain in _domains(domain_graph):
- if not domain.get("flows"):
- findings.append(Finding(
- check="domain_no_orphan",
- severity=Severity.CRITICAL,
- message=f"domain {domain.get('name', domain.get('slug', '?'))!r} has no flows",
- target=f"domain:{domain.get('slug', '')}",
- ))
- return findings
-
-
-def check_flow_has_steps(domain_graph: dict) -> list[Finding]:
- """Every flow has at least one step.
-
- CRITICAL: a step-less flow renders an empty page and breaks the
- flow->step edge invariant.
- """
- findings: list[Finding] = []
- for domain in _domains(domain_graph):
- for flow in domain.get("flows", []):
- if not flow.get("steps"):
- findings.append(Finding(
- check="flow_has_steps",
- severity=Severity.CRITICAL,
- message=f"flow {flow.get('name', flow.get('slug', '?'))!r} has no steps",
- target=f"flow:{domain.get('slug', '')}/{flow.get('slug', '')}",
- ))
- return findings
-
-
-def check_step_maps_to_real_node(domain_graph: dict, nodes: list[dict]) -> list[Finding]:
- """Every step maps to at least one real (existing) file node id.
-
- CRITICAL: a step whose ``implements`` is empty, or references a node id that
- is not a known file node, is hallucinated membership. Synthesis drops these
- by construction, so a hit here signals a synthesis/parsing regression.
- """
- findings: list[Finding] = []
- file_ids = {n["id"] for n in nodes if _is_file_node(n) and n.get("id")}
- for domain in _domains(domain_graph):
- for flow in domain.get("flows", []):
- for step in flow.get("steps", []):
- implements = step.get("implements") or []
- target = f"flow:{domain.get('slug', '')}/{flow.get('slug', '')}#{step.get('order')}"
- if not implements:
- findings.append(Finding(
- check="step_maps_to_real_node",
- severity=Severity.CRITICAL,
- message="step maps to no implementing node",
- target=target,
- ))
- continue
- unknown = [nid for nid in implements if nid not in file_ids]
- if unknown:
- findings.append(Finding(
- check="step_maps_to_real_node",
- severity=Severity.CRITICAL,
- message=f"step references {len(unknown)} unknown node id(s)",
- target=target,
- detail={"sample": sorted(unknown)[:5]},
- ))
- return findings
-
-
-def check_step_order_valid(domain_graph: dict) -> list[Finding]:
- """Each flow's step orders form a contiguous 1..N sequence.
-
- CRITICAL: a gap, duplicate, or non-1-based order breaks the rendered
- sequence and the weighted ``flow_step`` edges.
- """
- findings: list[Finding] = []
- for domain in _domains(domain_graph):
- for flow in domain.get("flows", []):
- steps = flow.get("steps", [])
- if not steps:
- continue
- orders = [s.get("order") for s in steps]
- if any(o is None for o in orders) or sorted(orders) != list(
- range(1, len(orders) + 1)
- ):
- findings.append(Finding(
- check="step_order_valid",
- severity=Severity.CRITICAL,
- message="flow step order is not a contiguous 1..N sequence",
- target=f"flow:{domain.get('slug', '')}/{flow.get('slug', '')}",
- detail={"orders": orders},
- ))
- return findings
-
-
def check_layer_name_category(layers: list[dict], nodes: list[dict]) -> list[Finding]:
"""A layer name may not assert a runtime category its files do not live in.
diff --git a/packages/core/src/repowise/core/generation/kg_reviewer/runner.py b/packages/core/src/repowise/core/generation/kg_reviewer/runner.py
index df6f17718..f3f644d49 100644
--- a/packages/core/src/repowise/core/generation/kg_reviewer/runner.py
+++ b/packages/core/src/repowise/core/generation/kg_reviewer/runner.py
@@ -20,13 +20,12 @@ from .findings import ReviewReport
logger = structlog.get_logger(__name__)
-def _kg_parts(kg: Any) -> tuple[list[dict], list[dict], list[dict], dict]:
- """Extract (nodes, layers, tour, domain_graph) from a KG-like object."""
+def _kg_parts(kg: Any) -> tuple[list[dict], list[dict], list[dict]]:
+ """Extract (nodes, layers, tour) from a KnowledgeGraphResult-like object."""
nodes = list(getattr(kg, "nodes", None) or [])
layers = list(getattr(kg, "layers", None) or [])
tour = list(getattr(kg, "tour", None) or [])
- domain_graph = getattr(kg, "domain_graph", None) or {}
- return nodes, layers, tour, domain_graph
+ return nodes, layers, tour
def run_review(kg: Any) -> ReviewReport:
@@ -35,7 +34,7 @@ def run_review(kg: Any) -> ReviewReport:
Pure and side-effect free. *kg* is any object exposing ``nodes``,
``layers``, and ``tour`` (the in-memory ``KnowledgeGraphResult``).
"""
- nodes, layers, tour, domain_graph = _kg_parts(kg)
+ nodes, layers, tour = _kg_parts(kg)
findings = [
*checks.check_summaries_restate_filename(nodes),
*checks.check_tour_reasons_distinct(tour),
@@ -43,13 +42,6 @@ def run_review(kg: Any) -> ReviewReport:
*checks.check_tour_sequential(tour),
*checks.check_layer_name_category(layers, nodes),
]
- if domain_graph:
- findings += [
- *checks.check_no_orphan_domains(domain_graph),
- *checks.check_flow_has_steps(domain_graph),
- *checks.check_step_maps_to_real_node(domain_graph, nodes),
- *checks.check_step_order_valid(domain_graph),
- ]
return ReviewReport(findings=findings)
diff --git a/packages/core/src/repowise/core/generation/knowledge_graph.py b/packages/core/src/repowise/core/generation/knowledge_graph.py
index cb01bd007..e42386ed4 100644
--- a/packages/core/src/repowise/core/generation/knowledge_graph.py
+++ b/packages/core/src/repowise/core/generation/knowledge_graph.py
@@ -51,7 +51,6 @@ async def enrich_knowledge_graph(
generated_pages: list[Any] | None = None,
progress: Any | None = None,
reasoning: str = "auto",
- prior_domain_graph: dict | None = None,
) -> Any:
"""Enrich deterministic KG with LLM-generated layer names and tour."""
enriched_layers = await _enrich_layers(
@@ -91,14 +90,6 @@ async def enrich_knowledge_graph(
kg_skeleton.layers = enriched_layers
kg_skeleton.tour = tour
- # Behavior-oriented domain graph (Domain -> Flow -> Step). Synthesized from
- # the enriched layers + file summaries + import edges (not raw source), with
- # a fixed, bounded LLM budget. Best-effort: a failure leaves the structural
- # KG untouched and the domain graph empty.
- await _synthesize_domain_graph(
- kg_skeleton, llm_client, generated_pages, reasoning, prior_domain_graph
- )
-
# Post-generation invariant gate: validate the fully-assembled KG (layers,
# tour, summaries) against hard invariants and quality signals before it is
# persisted. Deterministic, zero-LLM, bounded (no regeneration loop) —
@@ -373,51 +364,6 @@ def build_deterministic_tour(
return steps
-# ---------------------------------------------------------------------------
-# Domain graph synthesis
-# ---------------------------------------------------------------------------
-
-
-def _page_summary_map(generated_pages: list[Any] | None) -> dict[str, str]:
- """target_path -> summary, from generated wiki pages (zero LLM cost)."""
- out: dict[str, str] = {}
- for p in generated_pages or []:
- summary = getattr(p, "summary", None) or ""
- target = getattr(p, "target_path", None) or ""
- if summary and target:
- out[target] = summary
- return out
-
-
-async def _synthesize_domain_graph(
- kg_skeleton: Any,
- llm_client: Any,
- generated_pages: list[Any] | None,
- reasoning: str,
- prior_domain_graph: dict | None,
-) -> None:
- """Synthesize + attach the domain graph; best-effort, never blocks export."""
- try:
- from repowise.core.generation.domain_graph import (
- DomainGraph,
- synthesize_domain_graph,
- )
-
- prior = DomainGraph.from_dict(prior_domain_graph) if prior_domain_graph else None
- graph = await synthesize_domain_graph(
- layers=kg_skeleton.layers,
- nodes=kg_skeleton.nodes,
- edges=kg_skeleton.edges,
- llm_client=llm_client,
- page_summaries=_page_summary_map(generated_pages),
- prior=prior,
- reasoning=reasoning,
- )
- kg_skeleton.domain_graph = graph.to_dict() if not graph.is_empty() else {}
- except Exception as exc: # pragma: no cover - defensive, never blocks export
- logger.warning("domain_graph_synthesis_failed", error=str(exc))
-
-
# ---------------------------------------------------------------------------
# Summary backfill
# ---------------------------------------------------------------------------
diff --git a/packages/core/src/repowise/core/persistence/crud/__init__.py b/packages/core/src/repowise/core/persistence/crud/__init__.py
index 2456375d2..950535cf0 100644
--- a/packages/core/src/repowise/core/persistence/crud/__init__.py
+++ b/packages/core/src/repowise/core/persistence/crud/__init__.py
@@ -21,7 +21,6 @@ from __future__ import annotations
from .analysis import * # noqa: F403
from .chat import * # noqa: F403
from .decisions import * # noqa: F403
-from .domain_graph import * # noqa: F403
from .external_systems import * # noqa: F403
from .git import * # noqa: F403
from .graph import * # noqa: F403
diff --git a/packages/core/src/repowise/core/persistence/crud/domain_graph.py b/packages/core/src/repowise/core/persistence/crud/domain_graph.py
deleted file mode 100644
index da51bb2de..000000000
--- a/packages/core/src/repowise/core/persistence/crud/domain_graph.py
+++ /dev/null
@@ -1,85 +0,0 @@
-"""CRUD operations for the behavior-oriented domain graph.
-
-Full-replace upserts mirroring the knowledge-graph CRUD (delete-then-insert per
-repo), so a re-index writes a clean graph and the call is safe to repeat. Row
-shapes are the dicts produced by
-``repowise.core.generation.domain_graph.flatten_nodes`` /
-``flatten_edges``.
-"""
-
-from __future__ import annotations
-
-import json
-
-from sqlalchemy import delete, select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from ..models import DomainGraphEdge, DomainGraphNode
-
-
-async def upsert_domain_graph_nodes(
- session: AsyncSession, repo_id: str, nodes: list[dict]
-) -> None:
- """Replace all domain-graph nodes for a repo (delete + bulk insert)."""
- await session.execute(
- delete(DomainGraphNode).where(DomainGraphNode.repository_id == repo_id)
- )
- for i, node in enumerate(nodes):
- session.add(
- DomainGraphNode(
- repository_id=repo_id,
- node_id=node["node_id"],
- kind=node["kind"],
- name=node.get("name", ""),
- summary=node.get("summary", ""),
- parent_id=node.get("parent_id"),
- step_order=node.get("step_order"),
- implements_json=json.dumps(node.get("implements", [])),
- display_order=node.get("display_order", i),
- page_title=node.get("page_title", ""),
- page_content=node.get("page_content", ""),
- )
- )
- await session.flush()
-
-
-async def upsert_domain_graph_edges(
- session: AsyncSession, repo_id: str, edges: list[dict]
-) -> None:
- """Replace all domain-graph edges for a repo (delete + bulk insert)."""
- await session.execute(
- delete(DomainGraphEdge).where(DomainGraphEdge.repository_id == repo_id)
- )
- for edge in edges:
- session.add(
- DomainGraphEdge(
- repository_id=repo_id,
- source_node_id=edge["source_node_id"],
- target_node_id=edge["target_node_id"],
- edge_type=edge["edge_type"],
- weight=float(edge.get("weight", 0.0)),
- )
- )
- await session.flush()
-
-
-async def get_domain_graph_nodes(
- session: AsyncSession, repo_id: str
-) -> list[DomainGraphNode]:
- """Fetch all domain-graph nodes for a repo, ordered for stable display."""
- result = await session.execute(
- select(DomainGraphNode)
- .where(DomainGraphNode.repository_id == repo_id)
- .order_by(DomainGraphNode.kind, DomainGraphNode.display_order)
- )
- return list(result.scalars())
-
-
-async def get_domain_graph_edges(
- session: AsyncSession, repo_id: str
-) -> list[DomainGraphEdge]:
- """Fetch all domain-graph edges for a repo."""
- result = await session.execute(
- select(DomainGraphEdge).where(DomainGraphEdge.repository_id == repo_id)
- )
- return list(result.scalars())
diff --git a/packages/core/src/repowise/core/persistence/models.py b/packages/core/src/repowise/core/persistence/models.py
index 232f80b5a..2d7f4f3e5 100644
--- a/packages/core/src/repowise/core/persistence/models.py
+++ b/packages/core/src/repowise/core/persistence/models.py
@@ -1105,83 +1105,6 @@ class KnowledgeGraphNodeMeta(Base):
__table_args__ = (UniqueConstraint("repository_id", "node_id", name="uq_kg_node_meta"),)
-class DomainGraphNode(Base):
- """A node in the behavior-oriented domain graph (Domain / Flow / Step).
-
- Mirrors the discriminated single-table shape of :class:`GraphNode`: one
- table holds all three levels, distinguished by ``kind``. ``node_id`` is the
- stable synthesized id (``"domain:<slug>"`` / ``"flow:<domain>/<slug>"`` /
- ``"step:<flow>/<n>"``). ``implements_json`` holds a step's real implementing
- file node ids (and a domain's member file node ids); ``parent_id`` links a
- flow to its domain and a step to its flow.
-
- The renderable wiki page content (markdown) is persisted alongside the
- structural fields on the same row: domain and flow rows carry a
- ``page_title``/``page_content``; step rows leave them empty. This is the
- second persistence representation (graph rows + page content) the surfacing
- phase will embed; no consumer reads it yet.
- """
-
- __tablename__ = "domain_graph_nodes"
-
- id: Mapped[str] = mapped_column(String(32), primary_key=True, default=_new_uuid)
- repository_id: Mapped[str] = mapped_column(
- String(32), ForeignKey("repositories.id", ondelete="CASCADE"), nullable=False
- )
- node_id: Mapped[str] = mapped_column(Text, nullable=False)
- kind: Mapped[str] = mapped_column(String(16), nullable=False) # domain | flow | step
- name: Mapped[str] = mapped_column(Text, nullable=False, default="")
- summary: Mapped[str] = mapped_column(Text, nullable=False, default="")
- parent_id: Mapped[str | None] = mapped_column(Text, nullable=True)
- step_order: Mapped[int | None] = mapped_column(Integer, nullable=True)
- implements_json: Mapped[str] = mapped_column(Text, nullable=False, default="[]")
- display_order: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
- # Renderable wiki page content (markdown) + its title; populated for
- # domain/flow rows, empty for steps.
- page_title: Mapped[str] = mapped_column(Text, nullable=False, default="")
- page_content: Mapped[str] = mapped_column(Text, nullable=False, default="")
- created_at: Mapped[datetime] = mapped_column(
- DateTime(timezone=True), nullable=False, default=_now_utc
- )
-
- __table_args__ = (
- UniqueConstraint("repository_id", "node_id", name="uq_domain_graph_node"),
- )
-
-
-class DomainGraphEdge(Base):
- """A typed edge in the domain graph.
-
- ``edge_type`` is one of ``contains_flow`` (domain->flow), ``flow_step``
- (flow->step, ``weight`` = step order), or ``cross_domain`` (domain->domain,
- ``weight`` = crossing-import count). Mirrors :class:`GraphEdge`'s shape.
- """
-
- __tablename__ = "domain_graph_edges"
-
- id: Mapped[str] = mapped_column(String(32), primary_key=True, default=_new_uuid)
- repository_id: Mapped[str] = mapped_column(
- String(32), ForeignKey("repositories.id", ondelete="CASCADE"), nullable=False
- )
- source_node_id: Mapped[str] = mapped_column(Text, nullable=False)
- target_node_id: Mapped[str] = mapped_column(Text, nullable=False)
- edge_type: Mapped[str] = mapped_column(String(32), nullable=False)
- weight: Mapped[float] = mapped_column(Float, nullable=False, default=0.0)
- created_at: Mapped[datetime] = mapped_column(
- DateTime(timezone=True), nullable=False, default=_now_utc
- )
-
- __table_args__ = (
- UniqueConstraint(
- "repository_id",
- "source_node_id",
- "target_node_id",
- "edge_type",
- name="uq_domain_graph_edge",
- ),
- )
-
-
class PipelineJob(Base):
"""Checkpoint/resume state for one execution of a pipeline phase.
diff --git a/packages/core/src/repowise/core/pipeline/orchestrator.py b/packages/core/src/repowise/core/pipeline/orchestrator.py
index 1438f468a..aded586ea 100644
--- a/packages/core/src/repowise/core/pipeline/orchestrator.py
+++ b/packages/core/src/repowise/core/pipeline/orchestrator.py
@@ -694,17 +694,12 @@ async def run_pipeline(
generated_pages=generated_pages,
progress=progress,
reasoning=_kg_reasoning,
- # When the KG was reused (fingerprint unchanged) it carries the
- # prior domain graph; pass it so unchanged domains skip the LLM.
- prior_domain_graph=getattr(knowledge_graph_result, "domain_graph", None) or None,
)
if progress:
- _dg = getattr(knowledge_graph_result, "domain_graph", None) or {}
progress.on_message(
"info",
f" ↳ KG enriched: {len(knowledge_graph_result.layers)} layers, "
- f"{len(knowledge_graph_result.tour)} tour steps, "
- f"{len(_dg.get('domains', []))} domains",
+ f"{len(knowledge_graph_result.tour)} tour steps",
)
_phase_done(progress, "knowledge_graph.enrich")
except (ValueError, KeyError, OSError, RuntimeError) as exc:
diff --git a/packages/core/src/repowise/core/pipeline/persist.py b/packages/core/src/repowise/core/pipeline/persist.py
index 6065ee544..699c30160 100644
--- a/packages/core/src/repowise/core/pipeline/persist.py
+++ b/packages/core/src/repowise/core/pipeline/persist.py
@@ -645,32 +645,6 @@ async def persist_generation(result: Any, session: Any, repo_id: str) -> None:
if file_node_meta:
await upsert_kg_node_meta(session, repo_id, file_node_meta)
- # ---- Domain graph (behavior-oriented Domain -> Flow -> Step) --------
- domain_graph = getattr(kg, "domain_graph", None) or {}
- if domain_graph.get("domains"):
- from repowise.core.generation.domain_graph import (
- DomainGraph,
- flatten_edges,
- flatten_nodes,
- )
- from repowise.core.persistence.crud import (
- upsert_domain_graph_edges,
- upsert_domain_graph_nodes,
- )
-
- graph = DomainGraph.from_dict(domain_graph)
- # Optional hottest-step risk annotation: flag steps touching a churn
- # hotspot, sourced from the per-file git metadata.
- hotspot_node_ids = {
- "file:" + gm.get("file_path", "")
- for gm in (result.git_metadata_list or [])
- if isinstance(gm, dict) and gm.get("is_hotspot") and gm.get("file_path")
- }
- await upsert_domain_graph_nodes(
- session, repo_id, flatten_nodes(graph, hotspot_node_ids)
- )
- await upsert_domain_graph_edges(session, repo_id, flatten_edges(graph))
-
async def persist_pipeline_result(
result: Any,
diff --git a/tests/unit/generation/test_domain_graph.py b/tests/unit/generation/test_domain_graph.py
deleted file mode 100644
index 208cbcd00..000000000
--- a/tests/unit/generation/test_domain_graph.py
+++ /dev/null
@@ -1,357 +0,0 @@
-"""Tests for the behavior-oriented domain graph (generation.domain_graph).
-
-Pure-logic units (context assembly, parsing + node-id validation, render,
-fingerprint cache, persistence mapping) plus the async synthesis orchestrator
-driven by a stub LLM - no live LLM, no DB.
-"""
-
-from __future__ import annotations
-
-import json
-from types import SimpleNamespace
-
-import pytest
-
-from repowise.core.generation.domain_graph import (
- DomainGraph,
- DomainNode,
- FlowNode,
- StepNode,
- cache,
- context,
- flatten_edges,
- flatten_nodes,
- parsing,
- render,
- synthesize_domain_graph,
-)
-from repowise.core.generation.domain_graph.synthesis import (
- DOMAIN_NAMING_SYSTEM,
-)
-
-
-def _node(path: str, *, pagerank: float = 0.0, summary: str = "") -> dict:
- return {"id": f"file:{path}", "filePath": path, "pagerank": pagerank, "summary": summary}
-
-
-def _layers() -> list[dict]:
- return [
- {"id": "layer:ingestion", "name": "Ingestion", "nodeIds": ["file:a.py", "file:b.py"]},
- {"id": "layer:health", "name": "Health", "nodeIds": ["file:c.py"]},
- {"id": "layer:empty", "name": "Empty", "nodeIds": []},
- ]
-
-
-def _nodes() -> list[dict]:
- return [
- _node("a.py", pagerank=0.9, summary="parses files"),
- _node("b.py", pagerank=0.1, summary="walks tree"),
- _node("c.py", pagerank=0.5, summary="scores health"),
- ]
-
-
-# ---------------------------------------------------------------------------
-# context (a)
-# ---------------------------------------------------------------------------
-
-
-def test_build_layer_clusters_drops_empty_and_ranks_by_pagerank():
- clusters = context.build_layer_clusters(_layers(), _nodes())
- ids = [c.layer_id for c in clusters]
- assert ids == ["layer:ingestion", "layer:health"] # empty layer dropped
- ingestion = clusters[0]
- assert ingestion.file_count == 2
- assert ingestion.top_files[0] == "a.py" # highest pagerank first
-
-
-def test_member_node_ids_union_sorted():
- members = context.member_node_ids(["layer:ingestion", "layer:health"], _layers(), _nodes())
- assert members == ["file:a.py", "file:b.py", "file:c.py"]
-
-
-def test_derive_cross_domain_edges_counts_boundary_imports():
- domains = [
- DomainNode(slug="idx", name="Indexing", member_node_ids=["file:a.py", "file:b.py"]),
- DomainNode(slug="hlth", name="Health", member_node_ids=["file:c.py"]),
- ]
- edges = [
- {"source": "file:a.py", "target": "file:c.py"}, # crosses idx -> hlth
- {"source": "file:a.py", "target": "file:b.py"}, # internal to idx
- ]
- cross = context.derive_cross_domain_edges(domains, edges)
- assert len(cross) == 1
- assert (cross[0].source, cross[0].target, cross[0].weight) == ("domain:idx", "domain:hlth", 1)
-
-
-def test_heaviest_internal_edges_only_within_members():
- members = {"file:a.py", "file:b.py"}
- edges = [
- {"source": "file:a.py", "target": "file:b.py", "weight": 5},
- {"source": "file:a.py", "target": "file:c.py", "weight": 9}, # leaves member set
- ]
- pairs = context.heaviest_internal_edges(members, edges)
- assert pairs == [("a.py", "b.py")]
-
-
-# ---------------------------------------------------------------------------
-# parsing + node-id validation (c)
-# ---------------------------------------------------------------------------
-
-
-def test_parse_domains_rejects_unknown_layers_and_dedupes_claims():
- content = json.dumps(
- {
- "domains": [
- {"slug": "idx", "name": "Indexing", "member_layer_ids": ["layer:ingestion", "layer:bogus"]},
- {"slug": "dup", "name": "Dup", "member_layer_ids": ["layer:ingestion"]}, # already claimed
- {"slug": "hlth", "name": "Health", "member_layer_ids": ["layer:health"]},
- ]
- }
- )
- domains = parsing.parse_domains(content, {"layer:ingestion", "layer:health"})
- slugs = [d.slug for d in domains]
- assert slugs == ["idx", "hlth"] # bogus rejected, dup dropped (no members left)
- assert domains[0].member_layer_ids == ["layer:ingestion"]
-
-
-def test_resolve_flows_rejects_hallucinated_node_ids():
- # The key anti-hallucination guarantee: an unknown file path is dropped, and
- # a step left with no real member is removed entirely.
- content = json.dumps(
- {
- "flows": [
- {
- "slug": "ingest",
- "name": "Ingest",
- "steps": [
- {"order": 1, "name": "parse", "implements": ["a.py", "ghost.py"]},
- {"order": 2, "name": "phantom", "implements": ["ghost.py"]},
- ],
- }
- ]
- }
- )
- flows = parsing.resolve_flows(content, {"file:a.py", "file:b.py"})
- assert len(flows) == 1
- steps = flows[0].steps
- assert len(steps) == 1 # phantom step dropped
- assert steps[0].order == 1
- assert steps[0].implements == ["file:a.py"] # ghost.py never survives
- # The hallucinated id appears nowhere in the resolved graph.
- assert all("ghost" not in nid for s in steps for nid in s.implements)
-
-
-def test_resolve_flows_renumbers_orders_contiguously():
- content = json.dumps(
- {
- "flows": [
- {
- "slug": "f",
- "name": "F",
- "steps": [
- {"order": 7, "name": "first", "implements": ["a.py"]},
- {"order": 9, "name": "second", "implements": ["b.py"]},
- ],
- }
- ]
- }
- )
- flows = parsing.resolve_flows(content, {"file:a.py", "file:b.py"})
- assert [s.order for s in flows[0].steps] == [1, 2]
-
-
-def test_resolve_flows_drops_flow_with_no_valid_steps():
- content = json.dumps(
- {"flows": [{"slug": "f", "name": "F", "steps": [{"order": 1, "implements": ["ghost.py"]}]}]}
- )
- assert parsing.resolve_flows(content, {"file:a.py"}) == []
-
-
-def test_parse_json_tolerates_code_fences():
- assert parsing.parse_json('```json\n{"a": 1}\n```') == {"a": 1}
- assert parsing.parse_json("garbage") is None
-
-
-# ---------------------------------------------------------------------------
-# render
-# ---------------------------------------------------------------------------
-
-
-def test_render_flow_page_lists_steps_and_marks_hotspots():
- domain = DomainNode(slug="idx", name="Indexing")
- flow = FlowNode(
- slug="ingest",
- name="Ingest",
- steps=[StepNode(order=1, name="parse", implements=["file:a.py", "file:b.py"])],
- )
- title, _summary, md = render.render_flow_page(domain, flow, hotspot_node_ids={"file:a.py"})
- assert title == "Ingest (Indexing)"
- assert "`a.py`" in md and "`b.py`" in md
- assert "hotspot" in md # step touches a hotspot file
-
-
-def test_render_domain_page_lists_flows():
- domain = DomainNode(
- slug="idx",
- name="Indexing",
- summary="Builds the index.",
- flows=[FlowNode(slug="ingest", name="Ingest", steps=[StepNode(order=1, name="p", implements=["file:a.py"])])],
- )
- title, _summary, md = render.render_domain_page(domain)
- assert title == "Indexing"
- assert "Ingest" in md
-
-
-# ---------------------------------------------------------------------------
-# cache
-# ---------------------------------------------------------------------------
-
-
-def test_domain_fingerprint_changes_with_members_and_summaries():
- fp1 = cache.domain_fingerprint(["file:a.py", "file:b.py"], {"file:a.py": "x", "file:b.py": "y"})
- fp2 = cache.domain_fingerprint(["file:b.py", "file:a.py"], {"file:a.py": "x", "file:b.py": "y"})
- fp3 = cache.domain_fingerprint(["file:a.py", "file:b.py"], {"file:a.py": "CHANGED", "file:b.py": "y"})
- assert fp1 == fp2 # order-independent
- assert fp1 != fp3 # summary change invalidates
-
-
-def test_domain_fingerprint_changes_with_internal_coupling():
- members = ["file:a.py", "file:b.py"]
- summaries = {"file:a.py": "x", "file:b.py": "y"}
- base = cache.domain_fingerprint(members, summaries)
- coupled = cache.domain_fingerprint(members, summaries, [("file:a.py", "file:b.py")])
- assert base != coupled # a new internal edge invalidates the cache
-
-
-def test_reuse_flows_matches_on_slug_and_fingerprint():
- flows = [FlowNode(slug="f", name="F", steps=[StepNode(order=1, name="s", implements=["file:a.py"])])]
- prior = DomainGraph(domains=[DomainNode(slug="idx", name="Indexing", fingerprint="abc", flows=flows)])
- match = DomainNode(slug="idx", name="Indexing", fingerprint="abc")
- miss = DomainNode(slug="idx", name="Indexing", fingerprint="different")
- assert cache.reuse_flows(prior, match) is not None
- assert cache.reuse_flows(prior, miss) is None
- assert cache.reuse_flows(None, match) is None
-
-
-# ---------------------------------------------------------------------------
-# persistence mapping (d)
-# ---------------------------------------------------------------------------
-
-
-def test_flatten_nodes_and_edges_shapes():
- g = DomainGraph(
- domains=[
- DomainNode(
- slug="idx",
- name="Indexing",
- member_node_ids=["file:a.py"],
- flows=[FlowNode(slug="ingest", name="Ingest", steps=[StepNode(order=1, name="parse", implements=["file:a.py"])])],
- )
- ]
- )
- nodes = flatten_nodes(g)
- kinds = [n["kind"] for n in nodes]
- assert kinds == ["domain", "flow", "step"]
- step_row = nodes[2]
- assert step_row["node_id"] == "step:idx/ingest/1"
- assert step_row["parent_id"] == "flow:idx/ingest"
- edges = flatten_edges(g)
- types = {e["edge_type"] for e in edges}
- assert types == {"contains_flow", "flow_step"}
-
-
-# ---------------------------------------------------------------------------
-# synthesis (async orchestration with a stub LLM)
-# ---------------------------------------------------------------------------
-
-
-class _StubLLM:
- """Returns canned JSON keyed on whether it's the naming or a flow prompt."""
-
- def __init__(self, naming: str, flows_by_domain: dict[str, str]):
- self._naming = naming
- self._flows = flows_by_domain
- self.calls = 0
-
- async def generate(self, system, user, **kwargs):
- self.calls += 1
- if system == DOMAIN_NAMING_SYSTEM:
- return SimpleNamespace(content=self._naming)
- for name, resp in self._flows.items():
- if name in user:
- return SimpleNamespace(content=resp)
- return SimpleNamespace(content='{"flows": []}')
-
-
-async def test_synthesize_end_to_end_validates_and_links():
- naming = json.dumps(
- {
- "domains": [
- {"slug": "idx", "name": "Indexing", "member_layer_ids": ["layer:ingestion"]},
- {"slug": "hlth", "name": "Health", "member_layer_ids": ["layer:health"]},
- ]
- }
- )
- flows = {
- "Indexing": json.dumps(
- {"flows": [{"slug": "ingest", "name": "Ingest", "steps": [
- {"order": 1, "name": "parse", "implements": ["a.py", "ghost.py"]}]}]}
- ),
- "Health": json.dumps(
- {"flows": [{"slug": "score", "name": "Score", "steps": [
- {"order": 1, "name": "rate", "implements": ["c.py"]}]}]}
- ),
- }
- llm = _StubLLM(naming, flows)
- edges = [{"source": "file:a.py", "target": "file:c.py"}] # idx -> hlth
- graph = await synthesize_domain_graph(_layers(), _nodes(), edges, llm)
-
- assert [d.slug for d in graph.domains] == ["idx", "hlth"]
- idx = graph.domains[0]
- assert idx.flows[0].steps[0].implements == ["file:a.py"] # ghost rejected
- assert llm.calls == 3 # 1 naming + 2 flow
- assert len(graph.cross_domain) == 1
- assert (graph.cross_domain[0].source, graph.cross_domain[0].target) == ("domain:idx", "domain:hlth")
-
-
-async def test_synthesize_drops_orphan_domains():
- naming = json.dumps(
- {"domains": [
- {"slug": "idx", "name": "Indexing", "member_layer_ids": ["layer:ingestion"]},
- {"slug": "hlth", "name": "Health", "member_layer_ids": ["layer:health"]},
- ]}
- )
- flows = {
- "Indexing": json.dumps({"flows": [{"slug": "ingest", "name": "Ingest", "steps": [
- {"order": 1, "name": "parse", "implements": ["a.py"]}]}]}),
- "Health": '{"flows": []}', # no flows -> Health is an orphan
- }
- graph = await synthesize_domain_graph(_layers(), _nodes(), [], _StubLLM(naming, flows))
- assert [d.slug for d in graph.domains] == ["idx"] # Health dropped
-
-
-async def test_synthesize_empty_when_no_clusters():
- graph = await synthesize_domain_graph([], [], [], _StubLLM("{}", {}))
- assert graph.is_empty()
-
-
-async def test_synthesize_reuses_cached_domain_without_llm_call():
- naming = json.dumps(
- {"domains": [{"slug": "idx", "name": "Indexing", "member_layer_ids": ["layer:ingestion"]}]}
- )
- # First run to learn the fingerprint + flows.
- flows = {"Indexing": json.dumps({"flows": [{"slug": "ingest", "name": "Ingest", "steps": [
- {"order": 1, "name": "parse", "implements": ["a.py"]}]}]})}
- first = await synthesize_domain_graph(_layers(), _nodes(), [], _StubLLM(naming, flows))
- prior = first
-
- # Second run with the prior graph: the flow call must be skipped (only the
- # naming call fires) because the member fingerprint is unchanged.
- llm2 = _StubLLM(naming, flows)
- second = await synthesize_domain_graph(_layers(), _nodes(), [], llm2, prior=prior)
- assert llm2.calls == 1 # naming only; flows reused
- assert second.domains[0].flows[0].steps[0].implements == ["file:a.py"]
diff --git a/tests/unit/generation/test_kg_reviewer.py b/tests/unit/generation/test_kg_reviewer.py
index eebd90998..35d743dde 100644
--- a/tests/unit/generation/test_kg_reviewer.py
+++ b/tests/unit/generation/test_kg_reviewer.py
@@ -199,84 +199,3 @@ def test_apply_review_tags_low_signal_summaries():
# Idempotent — re-applying does not duplicate the tag.
apply_review(kg)
assert nodes[0]["tags"].count("low_signal_summary") == 1
-
-
-# ---------------------------------------------------------------------------
-# domain-graph invariants
-# ---------------------------------------------------------------------------
-
-
-def _domain_graph(flows, *, slug="idx", name="Indexing"):
- return {"domains": [{"slug": slug, "name": name, "flows": flows}], "cross_domain": []}
-
-
-def _good_step():
- return {"order": 1, "name": "parse", "implements": ["file:a.py"]}
-
-
-def test_check_no_orphan_domains_flags_domain_without_flows():
- findings = checks.check_no_orphan_domains(_domain_graph([]))
- assert len(findings) == 1
- assert findings[0].severity is Severity.CRITICAL
- assert findings[0].check == "domain_no_orphan"
-
-
-def test_check_flow_has_steps_flags_empty_flow():
- dg = _domain_graph([{"slug": "f", "name": "F", "steps": []}])
- findings = checks.check_flow_has_steps(dg)
- assert len(findings) == 1 and findings[0].severity is Severity.CRITICAL
-
-
-def test_check_step_maps_to_real_node_flags_unknown_and_empty():
- nodes = [_node("a.py")]
- dg = _domain_graph([
- {"slug": "f", "name": "F", "steps": [
- {"order": 1, "name": "ok", "implements": ["file:a.py"]},
- {"order": 2, "name": "ghost", "implements": ["file:nope.py"]},
- {"order": 3, "name": "empty", "implements": []},
- ]},
- ])
- findings = checks.check_step_maps_to_real_node(dg, nodes)
- # The valid step produces no finding; the unknown + empty steps each do.
- assert len(findings) == 2
- assert all(f.severity is Severity.CRITICAL for f in findings)
-
-
-def test_check_step_order_valid_flags_gap():
- dg = _domain_graph([
- {"slug": "f", "name": "F", "steps": [
- {"order": 1, "implements": ["file:a.py"]},
- {"order": 3, "implements": ["file:a.py"]},
- ]},
- ])
- findings = checks.check_step_order_valid(dg)
- assert len(findings) == 1 and findings[0].severity is Severity.CRITICAL
-
-
-def test_run_review_includes_domain_checks_when_present():
- nodes = [_node("a.py", summary="a module.")]
- layers = [{"id": "layer:x", "nodeIds": ["file:a.py"]}]
- kg = SimpleNamespace(
- nodes=nodes,
- layers=layers,
- tour=[],
- domain_graph=_domain_graph([{"slug": "f", "name": "F", "steps": [_good_step()]}]),
- )
- report = run_review(kg)
- assert report.ok # a well-formed domain graph passes
-
-
-def test_run_review_flags_bad_domain_graph():
- nodes = [_node("a.py", summary="a module.")]
- layers = [{"id": "layer:x", "nodeIds": ["file:a.py"]}]
- kg = SimpleNamespace(
- nodes=nodes,
- layers=layers,
- tour=[],
- domain_graph=_domain_graph([{"slug": "f", "name": "F", "steps": [
- {"order": 1, "name": "ghost", "implements": ["file:hallucinated.py"]},
- ]}]),
- )
- report = run_review(kg)
- assert not report.ok
- assert any(f.check == "step_maps_to_real_node" for f in report.criticals)
diff --git a/tests/unit/persistence/test_models.py b/tests/unit/persistence/test_models.py
index 8460875cb..e13db2c55 100644
--- a/tests/unit/persistence/test_models.py
+++ b/tests/unit/persistence/test_models.py
@@ -323,7 +323,5 @@ def test_base_includes_all_models():
"knowledge_graph_tour_steps",
"kg_project_meta",
"kg_node_meta",
- "domain_graph_nodes",
- "domain_graph_edges",
}
assert expected == table_names