Understand any codebase instantly. System intelligence for codebases, built for humans and AI.
TypeScript aiai-memoryclaude-codeclicode-analysiscode-mappingcode-memorycodebase-understandingcodexdeveloper-toolsllmopenclawpersistent-memoryprogram-analysissoftware-architecturesystem-intelligencesystem-mapping
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.scalaindex 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.scalaindex 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.apiimport io.circe.Jsonimport 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.scalaindex 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.scalaindex 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.Encoderimport 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.scalaindex 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)).toVectorregions = 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.scalaindex 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,