Skip to content

armgit / Ix

Public Imported from GitHub
0

Understand any codebase instantly. System intelligence for codebases, built for humans and AI.

Add backend-backed symbol graph projection

Sam Braude20df677e7343
diff --git a/memory-layer/src/main/scala/ix/memory/api/ExpandRoutes.scala b/memory-layer/src/main/scala/ix/memory/api/ExpandRoutes.scala
index 5ec79082..e2034aca 100644
--- a/memory-layer/src/main/scala/ix/memory/api/ExpandRoutes.scala
+++ b/memory-layer/src/main/scala/ix/memory/api/ExpandRoutes.scala
@@ -52,7 +52,8 @@ class ExpandRoutes(queryApi: GraphQueryApi) {
}
preds = body.predicates.map(_.toSet)
result <- queryApi.expand(nodeId, dir, preds, body.hops.getOrElse(1), body.asOfRev.map(Rev(_)))
- resp <- Ok(result.asJson)
+ projection <- queryApi.projectExpand(nodeId, dir, preds, body.hops.getOrElse(1), body.asOfRev.map(Rev(_)))
+ resp <- Ok(result.copy(projection = projection).asJson)
} yield resp).handleErrorWith(ErrorHandler.handle(_))
case req @ POST -> Root / "v1" / "expand-by-name" =>
diff --git a/memory-layer/src/main/scala/ix/memory/api/MapEncoder.scala b/memory-layer/src/main/scala/ix/memory/api/MapEncoder.scala
index d721f84e..14a2b333 100644
--- a/memory-layer/src/main/scala/ix/memory/api/MapEncoder.scala
+++ b/memory-layer/src/main/scala/ix/memory/api/MapEncoder.scala
@@ -3,7 +3,7 @@ package ix.memory.api
import io.circe.Json
import io.circe.syntax._
-import ix.memory.map.{ArchitectureMap, Region, RegionMatch, ScopedSubsystemView}
+import ix.memory.map.{ArchitectureEdge, ArchitectureMap, Region, RegionMatch, ScopedSubsystemView}
import ix.memory.model.NodeId
/** Shared JSON encoding for ArchitectureMap, used by MapRoutes and SubsystemRoutes. */
@@ -17,6 +17,7 @@ object MapEncoder {
"levels" -> regionsByLevel.size.asJson,
"map_rev" -> m.mapRev.asJson,
"regions" -> m.regions.sortBy(r => (r.level, r.label)).map(encodeRegion).asJson,
+ "edges" -> m.edges.sortBy(e => (e.level, e.src.value.toString, e.dst.value.toString)).map(encodeEdge).asJson,
"hierarchy" -> buildHierarchyTree(m).asJson
)
}
@@ -39,6 +40,17 @@ object MapEncoder {
"interface_node_count" -> r.interfaceNodeCount.asJson
)
+ def encodeEdge(edge: ArchitectureEdge): Json =
+ Json.obj(
+ "id" -> edge.id.asJson,
+ "src" -> edge.src.value.toString.asJson,
+ "dst" -> edge.dst.value.toString.asJson,
+ "level" -> edge.level.asJson,
+ "weight" -> edge.weight.asJson,
+ "dominant_signal" -> edge.dominantSignal.asJson,
+ "predicate_counts" -> edge.predicateCounts.asJson
+ )
+
def encodeScopedView(view: ScopedSubsystemView, isCrossCutting: Region => Boolean): Json =
Json.obj(
"target" -> encodeScopedRegion(view.target, isCrossCutting).asJson,
diff --git a/memory-layer/src/main/scala/ix/memory/db/ArangoGraphQueryApi.scala b/memory-layer/src/main/scala/ix/memory/db/ArangoGraphQueryApi.scala
index 4a31b3e3..aa06be2a 100644
--- a/memory-layer/src/main/scala/ix/memory/db/ArangoGraphQueryApi.scala
+++ b/memory-layer/src/main/scala/ix/memory/db/ArangoGraphQueryApi.scala
@@ -14,6 +14,23 @@ import ix.memory.model._
class ArangoGraphQueryApi(client: ArangoClient) extends GraphQueryApi {
private val log = LoggerFactory.getLogger(classOf[ArangoGraphQueryApi])
+ private val SymbolProjectionKinds = Vector(
+ NodeKind.Function,
+ NodeKind.Method,
+ NodeKind.Class,
+ NodeKind.Interface,
+ NodeKind.Trait,
+ NodeKind.Object,
+ NodeKind.Variable,
+ )
+ private val SymbolProjectionPredicates = Set(
+ "CONTAINS",
+ "CALLS",
+ "IMPORTS",
+ "REFERENCES",
+ "EXTENDS",
+ "IMPLEMENTS",
+ )
// ── Public API ──────────────────────────────────────────────────────
@@ -271,6 +288,24 @@ class ArangoGraphQueryApi(client: ArangoClient) extends GraphQueryApi {
} yield ExpandResult(nodes, allEdges)
}
+ override def projectExpand(
+ nodeId: NodeId,
+ direction: Direction,
+ predicates: Option[Set[String]] = None,
+ hops: Int = 1,
+ asOfRev: Option[Rev] = None
+ ): IO[Option[ExpandProjection]] =
+ for {
+ resolvedRev <- asOfRev.fold(getLatestRev)(IO.pure)
+ originOpt <- getNode(nodeId, Some(resolvedRev))
+ projection <- originOpt match {
+ case Some(origin) if origin.kind == NodeKind.File =>
+ buildFileSymbolProjection(origin, resolvedRev, predicates)
+ case _ =>
+ IO.pure(None)
+ }
+ } yield projection
+
override def getClaims(entityId: NodeId): IO[Vector[Claim]] =
client.query(
"""FOR c IN claims
@@ -537,6 +572,66 @@ class ArangoGraphQueryApi(client: ArangoClient) extends GraphQueryApi {
} yield ExpandResult(nodes, allEdges)
}
+ private def buildFileSymbolProjection(
+ fileNode: GraphNode,
+ rev: Rev,
+ predicates: Option[Set[String]]
+ ): IO[Option[ExpandProjection]] = {
+ val activePredicates = predicates
+ .map(_.intersect(SymbolProjectionPredicates))
+ .getOrElse(SymbolProjectionPredicates)
+
+ val kindList = new java.util.ArrayList[String](SymbolProjectionKinds.size)
+ SymbolProjectionKinds.foreach(kind => kindList.add(nodeKindToString(kind)))
+
+ val symbolNodeQuery =
+ """FOR n IN nodes
+ | FILTER n.provenance.source_uri == @sourceUri
+ | AND n.kind IN @symbolKinds
+ | AND n.created_rev <= @rev
+ | AND (n.deleted_rev == null OR @rev < n.deleted_rev)
+ | SORT TO_NUMBER(n.attrs.line_start), TO_NUMBER(n.attrs.line_end), n.name ASC
+ | RETURN n""".stripMargin
+
+ for {
+ symbolRows <- client.query(
+ symbolNodeQuery,
+ Map(
+ "sourceUri" -> fileNode.provenance.sourceUri.asInstanceOf[AnyRef],
+ "symbolKinds" -> kindList.asInstanceOf[AnyRef],
+ "rev" -> Long.box(rev.value).asInstanceOf[AnyRef],
+ ),
+ )
+ symbolNodes = symbolRows.flatMap(parseNode).toVector
+ edgeRows <- if (symbolNodes.isEmpty || activePredicates.isEmpty) IO.pure(Vector.empty[Json])
+ else {
+ val idList = new java.util.ArrayList[String](symbolNodes.size)
+ symbolNodes.foreach(node => idList.add(node.id.value.toString))
+ val predicateList = new java.util.ArrayList[String](activePredicates.size)
+ activePredicates.toVector.sorted.foreach(predicateList.add)
+ client.query(
+ """FOR e IN edges
+ | FILTER e.src IN @ids
+ | AND e.dst IN @ids
+ | AND e.predicate IN @predicates
+ | AND e.created_rev <= @rev
+ | AND (e.deleted_rev == null OR @rev < e.deleted_rev)
+ | RETURN e""".stripMargin,
+ Map(
+ "ids" -> idList.asInstanceOf[AnyRef],
+ "predicates" -> predicateList.asInstanceOf[AnyRef],
+ "rev" -> Long.box(rev.value).asInstanceOf[AnyRef],
+ ),
+ )
+ }
+ symbolEdges = edgeRows.flatMap(parseEdge).toVector
+ } yield Some(ExpandProjection(
+ kind = "symbol_graph",
+ nodes = symbolNodes,
+ edges = symbolEdges,
+ ))
+ }
+
// ── JSON Parsers (snake_case → camelCase) ───────────────────────────
private def parseNode(json: Json): Option[GraphNode] = {
diff --git a/memory-layer/src/main/scala/ix/memory/db/GraphQueryApi.scala b/memory-layer/src/main/scala/ix/memory/db/GraphQueryApi.scala
index a3e20915..ee6246d1 100644
--- a/memory-layer/src/main/scala/ix/memory/db/GraphQueryApi.scala
+++ b/memory-layer/src/main/scala/ix/memory/db/GraphQueryApi.scala
@@ -25,6 +25,13 @@ trait GraphQueryApi {
def resolvePrefix(prefix: String): IO[Vector[NodeId]]
def getSourceHashes(sourceUris: Seq[String]): IO[Map[String, String]]
def hasIngestBaseline(): IO[Boolean]
+ def projectExpand(
+ nodeId: NodeId,
+ direction: Direction,
+ predicates: Option[Set[String]] = None,
+ hops: Int = 1,
+ asOfRev: Option[Rev] = None
+ ): IO[Option[ExpandProjection]] = IO.pure(None)
def expandByName(
name: String,
direction: Direction,
@@ -40,10 +47,21 @@ object Direction {
case object Both extends Direction
}
-final case class ExpandResult(nodes: Vector[GraphNode], edges: Vector[GraphEdge])
+final case class ExpandProjection(
+ kind: String,
+ nodes: Vector[GraphNode],
+ edges: Vector[GraphEdge]
+)
+
+final case class ExpandResult(
+ nodes: Vector[GraphNode],
+ edges: Vector[GraphEdge],
+ projection: Option[ExpandProjection] = None
+)
object ExpandResult {
import io.circe.Encoder
import io.circe.generic.semiauto.deriveEncoder
+ implicit val projectionEncoder: Encoder[ExpandProjection] = deriveEncoder[ExpandProjection]
implicit val encoder: Encoder[ExpandResult] = deriveEncoder[ExpandResult]
}
diff --git a/memory-layer/src/main/scala/ix/memory/map/MapService.scala b/memory-layer/src/main/scala/ix/memory/map/MapService.scala
index f1c5c96a..def439fb 100644
--- a/memory-layer/src/main/scala/ix/memory/map/MapService.scala
+++ b/memory-layer/src/main/scala/ix/memory/map/MapService.scala
@@ -582,6 +582,110 @@ class MapService(
if (ranked.nonEmpty) ranked else List("path")
}
+ private def canonicalRegionPair(a: NodeId, b: NodeId): (NodeId, NodeId) =
+ if (a.value.toString <= b.value.toString) (a, b) else (b, a)
+
+ private def signalCategory(predicate: String): String =
+ predicate match {
+ case "CALLS" => "calls"
+ case "IMPORTS" => "imports"
+ case "EXTENDS" | "IMPLEMENTS" => "type"
+ case "PATH" => "path"
+ case other => other.toLowerCase
+ }
+
+ private def computeArchitectureEdges(
+ regions: Vector[Region],
+ graph: WeightedFileGraph
+ ): Vector[ArchitectureEdge] = {
+ if (regions.isEmpty || graph.predicatePairs.isEmpty) return Vector.empty
+
+ def buildEdge(
+ idSeed: String,
+ src: NodeId,
+ dst: NodeId,
+ level: Int,
+ predicateCounts: Map[String, Int]
+ ): Option[ArchitectureEdge] = {
+ val signalScores = predicateCounts.toVector
+ .map { case (predicate, count) =>
+ signalCategory(predicate) -> (SignalWeights.getOrElse(predicate, 0.0) * math.log1p(count.toDouble))
+ }
+ .groupBy(_._1)
+ .view
+ .mapValues(_.map(_._2).sum)
+ .toMap
+
+ val weight = signalScores.values.sum
+ if (weight <= 0.0) None
+ else {
+ val dominantSignal = signalScores.toVector
+ .sortBy { case (signal, score) => (-score, signal) }
+ .headOption
+ .map(_._1)
+ .getOrElse("path")
+
+ Some(ArchitectureEdge(
+ id = UUID.nameUUIDFromBytes(idSeed.getBytes("UTF-8")).toString,
+ src = src,
+ dst = dst,
+ level = level,
+ weight = weight,
+ dominantSignal = dominantSignal,
+ predicateCounts = predicateCounts,
+ ))
+ }
+ }
+
+ val fileEdges = graph.predicatePairs.toVector.flatMap { case ((src, dst), predicateCounts) =>
+ buildEdge(
+ idSeed = s"map:file-edge:${src.value}:${dst.value}",
+ src = src,
+ dst = dst,
+ level = 0,
+ predicateCounts = predicateCounts.filter(_._2 > 0),
+ )
+ }
+
+ val fileToRegionByLevel: Map[Int, Map[NodeId, Region]] = regions.groupBy(_.level).view.mapValues { levelRegions =>
+ levelRegions.toVector.flatMap(region =>
+ region.memberFiles.toVector.map(fileId => fileId -> region)
+ ).toMap
+ }.toMap
+
+ val aggregated = scala.collection.mutable.Map.empty[(Int, NodeId, NodeId), scala.collection.mutable.Map[String, Int]]
+
+ for {
+ ((srcFile, dstFile), predicateCounts) <- graph.predicatePairs
+ (level, byFile) <- fileToRegionByLevel
+ srcRegion <- byFile.get(srcFile)
+ dstRegion <- byFile.get(dstFile)
+ if srcRegion.id != dstRegion.id
+ } {
+ val (srcRegionId, dstRegionId) = canonicalRegionPair(srcRegion.id, dstRegion.id)
+ val bucket = aggregated.getOrElseUpdate(
+ (level, srcRegionId, dstRegionId),
+ scala.collection.mutable.Map.empty[String, Int],
+ )
+ predicateCounts.foreach { case (predicate, count) =>
+ bucket.update(predicate, bucket.getOrElse(predicate, 0) + count)
+ }
+ }
+
+ val regionEdges = aggregated.toVector.flatMap { case ((level, src, dst), predicateCountsMut) =>
+ val predicateCounts = predicateCountsMut.toMap.filter(_._2 > 0)
+ buildEdge(
+ idSeed = s"map:region-edge:$level:${src.value}:${dst.value}",
+ src = src,
+ dst = dst,
+ level = level,
+ predicateCounts = predicateCounts,
+ )
+ }
+
+ (regionEdges ++ fileEdges).sortBy(edge => (edge.level, edge.src.value.toString, edge.dst.value.toString))
+ }
+
// ── Confidence scoring ──────────────────────────────────────────────
private def computeConfidence(
@@ -607,7 +711,8 @@ class MapService(
graph = applyPenalty(rawGraph, crosscutScores)
levels = LouvainClustering.cluster(graph, maxLevels = 3, minCommunitySize = 3)
regions = buildRegions(graph, levels, crosscutScores, inputRev)
- fresh = ArchitectureMap(regions, rawGraph.vertices.size, inputRev.value)
+ edges = computeArchitectureEdges(regions, rawGraph)
+ fresh = ArchitectureMap(regions, edges, rawGraph.vertices.size, inputRev.value)
_ <- persistMap(fresh, cached)
} yield fresh
@@ -629,10 +734,18 @@ class MapService(
)
decoded = rows.flatMap(decodePersistedRegion(_, inputRev)).toVector
regions = rehydrateRelationships(decoded)
- fileCount <- if (regions.isEmpty) IO.pure(0) else builder.liveFileCount()
+ rawGraphOpt <- if (regions.isEmpty) IO.pure(None) else builder.build().map(Some(_))
} yield {
if (regions.isEmpty) None
- else Some(ArchitectureMap(regions, fileCount, inputRev.value))
+ else {
+ val rawGraph = rawGraphOpt.get
+ Some(ArchitectureMap(
+ regions,
+ computeArchitectureEdges(regions, rawGraph),
+ rawGraph.vertices.size,
+ inputRev.value,
+ ))
+ }
}
private def decodePersistedRegion(json: Json, inputRev: Rev): Option[Region] = {
diff --git a/memory-layer/src/main/scala/ix/memory/map/MapTypes.scala b/memory-layer/src/main/scala/ix/memory/map/MapTypes.scala
index f19e7101..b416fc2f 100644
--- a/memory-layer/src/main/scala/ix/memory/map/MapTypes.scala
+++ b/memory-layer/src/main/scala/ix/memory/map/MapTypes.scala
@@ -54,6 +54,16 @@ final case class Region(
mapRev: Long
)
+final case class ArchitectureEdge(
+ id: String,
+ src: NodeId,
+ dst: NodeId,
+ level: Int,
+ weight: Double,
+ dominantSignal: String,
+ predicateCounts: Map[String, Int]
+)
+
// ── Preflight types ──────────────────────────────────────────────────
sealed trait RiskTier { def label: String }
@@ -129,6 +139,7 @@ class MapCapacityException(
/** The full multi-level architecture map returned by MapService. */
final case class ArchitectureMap(
regions: Vector[Region],
+ edges: Vector[ArchitectureEdge],
fileCount: Int,
mapRev: Long,
preflight: Option[MapPreflightResult] = None,