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
Updating cli and memory layer to support Queries, no NLP. Adding improvements for Claim and contradiction support. Removing file specific parsing
Tanner Kocher443d6bdb536a
diff --git a/docker-compose.yml b/docker-compose.ymlindex b2ec0ba9..381180b7 100644--- a/docker-compose.yml+++ b/docker-compose.yml@@ -7,12 +7,6 @@ services:ARANGO_NO_AUTH: "1"volumes:- arangodb-data:/var/lib/arangodb3- healthcheck:- test: ["CMD", "wget", "--spider", "-q", "http://localhost:8529/_api/version"]- interval: 5s- timeout: 3s- start_period: 10s- retries: 5memory-layer:build: ./memory-layer@@ -28,8 +22,7 @@ services:ARANGO_PASSWORD: ""PORT: "8090"depends_on:- arangodb:- condition: service_healthy+ - arangodbhealthcheck:test: ["CMD", "curl", "-sf", "http://localhost:8090/v1/health"]interval: 10sdiff --git a/ix-cli/src/client/api.ts b/ix-cli/src/client/api.tsindex 95701eee..3b5bd386 100644--- a/ix-cli/src/client/api.ts+++ b/ix-cli/src/client/api.ts@@ -13,6 +13,7 @@ export class IxClient {question: string,opts?: { asOfRev?: number; depth?: string }): Promise<StructuredContext> {+ console.log("CLI depth:", opts?.depth);return this.post("/v1/context", { query: question, ...opts });}diff --git a/memory-layer/src/main/scala/ix/memory/api/ContextRoutes.scala b/memory-layer/src/main/scala/ix/memory/api/ContextRoutes.scalaindex 1ebacb45..870a6f09 100644--- a/memory-layer/src/main/scala/ix/memory/api/ContextRoutes.scala+++ b/memory-layer/src/main/scala/ix/memory/api/ContextRoutes.scala@@ -10,7 +10,7 @@ import org.http4s.dsl.io._import ix.memory.context.ContextServiceimport ix.memory.model.Rev-case class ContextRequest(query: String, asOfRev: Option[Long])+case class ContextRequest(query: String, asOfRev: Option[Long], depth: Option[String])object ContextRequest {implicit val decoder: Decoder[ContextRequest] = deriveDecoder[ContextRequest]@@ -24,7 +24,7 @@ class ContextRoutes(contextService: ContextService) {(for {body <- req.as[ContextRequest]asOfRev = body.asOfRev.map(Rev(_))- result <- contextService.query(body.query, asOfRev)+ result <- contextService.query(body.query, asOfRev, depth = body.depth)resp <- Ok(result)} yield resp).handleErrorWith(ErrorHandler.handle(_))}diff --git a/memory-layer/src/main/scala/ix/memory/context/ConflictDetector.scala b/memory-layer/src/main/scala/ix/memory/context/ConflictDetector.scalaindex 9732cfac..9c5c5382 100644--- a/memory-layer/src/main/scala/ix/memory/context/ConflictDetector.scala+++ b/memory-layer/src/main/scala/ix/memory/context/ConflictDetector.scala@@ -31,23 +31,50 @@ class ConflictDetectorImpl(llmJudge: Option[LlmJudge] = None) extends ConflictDeif (activeClaims.size < 2) Vector.emptyelse {- val pairs = activeClaims.combinations(2).toVector- val conflicts = pairs.flatMap {- case Vector(a, b) =>- if (a.claim.statement == b.claim.statement) {- None- }- else if (shareFieldPrefix(a.claim.statement, b.claim.statement)) {- Some(makeConflict(a, b, "Contradictory statements (same field)"))- }- else if (keywordsOverlap(a.claim.statement, b.claim.statement)) {- Some(makeConflict(a, b, "Contradictory statements (keyword overlap)"))- }+ // PASS 1: Hard conflicts (same statement/field, different values)+ val hardConflicts: Vector[ConflictReport] = {+ val byStatement = activeClaims.groupBy(_.claim.statement)++ byStatement.values.toVector.flatMap { sameFieldClaims =>+ // Group by value (stringified) to find distinct values for this field+ val byValue = sameFieldClaims.groupBy(sc => sc.claim.value.noSpaces)+ if (byValue.size <= 1) Vector.emptyelse {- None // unrelated claims — not a conflict+ // Pick one representative claim per distinct value (highest confidence wins)+ val reps = byValue.values.toVector.map { claimsForValue =>+ claimsForValue.maxBy(_.confidence.score)+ }+ val winner = reps.maxBy(_.confidence.score)++ // Emit one conflict per losing value against the winner+ reps.filterNot(_.claim.id == winner.claim.id).map { loser =>+ makeConflict(winner, loser, "Conflicting values for same field")+ }}- case _ => None- }.take(10)+ }+ }++ // PASS 2: Soft conflicts (heuristics) only if we found no hard conflicts.+ // These are useful for surfacing potential inconsistencies, but can be noisy.+ val softConflicts: Vector[ConflictReport] =+ if (hardConflicts.nonEmpty) Vector.empty+ else {+ val candidates = activeClaims.filter(sc => sc.relevance >= 0.25)+ val pairs = candidates.combinations(2).toVector+ pairs.flatMap {+ case Vector(a, b) =>+ if (shareFieldPrefix(a.claim.statement, b.claim.statement)) {+ Some(makeConflict(a, b, "Potential inconsistency (same field prefix)"))+ }+ else if (keywordsOverlap(a.claim.statement, b.claim.statement)) {+ Some(makeConflict(a, b, "Potential inconsistency (keyword overlap)"))+ }+ else None+ case _ => None+ }+ }++ val conflicts = (hardConflicts ++ softConflicts).take(10)if (conflicts.nonEmpty) {log.warn("Detected {} conflict(s) for entity {}", conflicts.size, entityClaims.head.claim.entityId.value)diff --git a/memory-layer/src/main/scala/ix/memory/context/ContextService.scala b/memory-layer/src/main/scala/ix/memory/context/ContextService.scalaindex 9fed36b5..6c9994c8 100644--- a/memory-layer/src/main/scala/ix/memory/context/ContextService.scala+++ b/memory-layer/src/main/scala/ix/memory/context/ContextService.scala@@ -18,6 +18,25 @@ class ContextService(asOfRev: Option[Rev] = None,depth: Option[String] = None): IO[StructuredContext] =for {+ // 0. Resolve revision + depth (used for scoring + output shaping)+ rev <- asOfRev.fold(queryApi.getLatestRev)(IO.pure)+ // Normalize depth values coming from different clients:+ // - MCP server may send shallow|deep+ // - CLI may send compact|standard|full+ effectiveDepthRaw = depth.getOrElse("standard").toLowerCase+ effectiveDepth = effectiveDepthRaw match {+ case "shallow" => "compact"+ case "deep" => "full"+ case other => other+ }++ // Strict limits to prevent huge MCP payloads+ (claimLimit, nodeLimit, edgeLimit, conflictLimit) = effectiveDepth match {+ case "compact" => (8, 8, 10, 3)+ case "full" => (250, 200, 800, 100)+ case _ => (30, 40, 120, 15) // standard+ }+// 1. Extract entity keywords from the natural language queryterms <- IO.pure(EntityExtractor.extract(question))@@ -35,7 +54,6 @@ class ContextService(stalenessMap <- StalenessDetector.detect(claims)// 5. Score each claim for confidence- rev <- asOfRev.fold(queryApi.getLatestRev)(IO.pure)corroborationMap = CorroborationCounter.count(claims)scored = claims.map { c =>confidenceScorer.score(c, ScoringContext(@@ -48,39 +66,63 @@ class ContextService())}- // 6. Detect conflicts among scored claims (Pass 1+2)- pass12Conflicts = conflictDetector.detect(scored)-- // 6.5. Refine conflicts with LLM (Pass 3, if available)- conflicts <- conflictDetector match {- case impl: ConflictDetectorImpl => impl.refineWithLlm(pass12Conflicts, scored)- case _ => IO.pure(pass12Conflicts)- }-// 7. Relevance score: weight claims by hop distance from seedsrelevant = RelevanceScorer.score(scored, seeds.map(_.id).toSet, expanded.edges)// 8. Rank claims by finalScore (relevance x confidence) descendingranked = ContextRanker.rank(relevant)- // Collect decisions and intents from expanded nodes- allNodes = (seeds ++ expanded.nodes).distinctBy(_.id)- decisions = allNodes.filter(_.kind == NodeKind.Decision).map(toDecisionReport(_, rev))- intents = allNodes.filter(_.kind == NodeKind.Intent).map(toIntentReport)+ // 8.5 Trim claims to strict limit (prevents massive MCP responses)+ rankedTrimmed = ranked.take(claimLimit)++ // 9. Detect conflicts only within the trimmed claim set+ pass12Conflicts = conflictDetector.detect(rankedTrimmed.toVector)++ // 9.5 Refine conflicts with LLM (Pass 3, if available) using the same trimmed claims+ conflictsAll <- conflictDetector match {+ case impl: ConflictDetectorImpl => impl.refineWithLlm(pass12Conflicts, rankedTrimmed.toVector)+ case _ => IO.pure(pass12Conflicts)+ }++ // Only surface hard conflicts in query responses.+ // Heuristic "Potential inconsistency" reports are too noisy for MCP/LLM output.+ hardConflictsOnly: Vector[ConflictReport] = conflictsAll.filterNot(_.reason.startsWith("Potential inconsistency"))+ conflictsTrimmed: Vector[ConflictReport] = hardConflictsOnly.take(conflictLimit)++ // Collect decisions and intents from expanded nodes (apply strict node/edge limits)+ allNodesAll: Vector[GraphNode] = (seeds ++ expanded.nodes).distinctBy(_.id)+ allNodes: Vector[GraphNode] = allNodesAll.take(nodeLimit)+ edgesTrimmed: Vector[GraphEdge] = expanded.edges.take(edgeLimit)++ // Lightweight summaries for LLM navigation (lets the model drill down with ix_entity/ix_expand)+ nodeSummaries: Vector[NodeSummary] = allNodes.map { n =>+ val display = n.attrs.hcursor.get[String]("name").getOrElse(n.id.value.toString)+ NodeSummary(n.id, n.kind, display, rev)+ }+ edgeSummaries: Vector[EdgeSummary] = edgesTrimmed.map(e => EdgeSummary(e.id, e.src, e.dst, e.predicate, rev))++ // In compact/standard, omit full nodes/edges to keep MCP payload small.+ nodesOut: Vector[GraphNode] = if (effectiveDepth == "full") allNodes else Vector.empty+ edgesOut: Vector[GraphEdge] = if (effectiveDepth == "full") edgesTrimmed else Vector.empty++ decisions: Vector[DecisionReport] = allNodes.filter(_.kind == NodeKind.Decision).map(toDecisionReport(_, rev))+ intents: Vector[IntentReport] = allNodes.filter(_.kind == NodeKind.Intent).map(toIntentReport)} yield StructuredContext(- claims = ranked.toList,- conflicts = conflicts.toList,- decisions = decisions.toList,- intents = intents.toList,- nodes = allNodes.toList,- edges = expanded.edges.toList,- metadata = ContextMetadata(+ claims = rankedTrimmed.toList,+ conflicts = conflictsTrimmed.toList,+ decisions = decisions.toList,+ intents = intents.toList,+ nodes = nodesOut.toList,+ edges = edgesOut.toList,+ nodeSummaries = nodeSummaries.toList,+ edgeSummaries = edgeSummaries.toList,+ metadata = ContextMetadata(query = question,- seedEntities = seeds.map(_.id).toList,+ seedEntities = seeds.map(_.id).take(25).toList,hopsExpanded = 1,asOfRev = rev,- depth = depth.orElse(Some("standard"))+ depth = Some(effectiveDepthRaw)))diff --git a/memory-layer/src/main/scala/ix/memory/db/ArangoGraphQueryApi.scala b/memory-layer/src/main/scala/ix/memory/db/ArangoGraphQueryApi.scalaindex fcecef21..eb22f2d6 100644--- a/memory-layer/src/main/scala/ix/memory/db/ArangoGraphQueryApi.scala+++ b/memory-layer/src/main/scala/ix/memory/db/ArangoGraphQueryApi.scala@@ -270,6 +270,8 @@ class ArangoGraphQueryApi(client: ArangoClient) extends GraphQueryApi {.flatMap(s => scala.util.Try(UUID.fromString(s)).toOption).map(NodeId(_))field <- c.get[String]("field").toOption+ value = c.downField("value").focus.getOrElse(Json.Null)+ confidence = c.get[Double]("confidence").toOptionstatusStr <- c.get[String]("status").toOptionstatus <- statusStr.toLowerCase match {case "active" => Some(ClaimStatus.Active)@@ -280,7 +282,7 @@ class ArangoGraphQueryApi(client: ArangoClient) extends GraphQueryApi {provenance <- parseProvenance(c.downField("provenance").focus)createdRev <- c.get[Long]("created_rev").toOption.map(Rev(_))deletedRev = c.get[Long]("deleted_rev").toOption.map(Rev(_))- } yield Claim(key, entityId, field, status, provenance, createdRev, deletedRev)+ } yield Claim(key, entityId, field, value, confidence, status, provenance, createdRev, deletedRev)if (result.isEmpty) log.warn("Failed to parse claim from JSON: {}", json.noSpaces.take(200))result}diff --git a/memory-layer/src/main/scala/ix/memory/ingestion/GraphPatchBuilder.scala b/memory-layer/src/main/scala/ix/memory/ingestion/GraphPatchBuilder.scalaindex a267fb0d..0c34aaca 100644--- a/memory-layer/src/main/scala/ix/memory/ingestion/GraphPatchBuilder.scala+++ b/memory-layer/src/main/scala/ix/memory/ingestion/GraphPatchBuilder.scala@@ -63,7 +63,7 @@ object GraphPatchBuilder {Vector(PatchOp.AssertClaim(entityId = nodeIdFor(e.name),field = key,- value = Json.fromString(value.noSpaces),+ value = value,confidence = None))}diff --git a/memory-layer/src/main/scala/ix/memory/ingestion/IngestionService.scala b/memory-layer/src/main/scala/ix/memory/ingestion/IngestionService.scalaindex 49200a64..e860d4e6 100644--- a/memory-layer/src/main/scala/ix/memory/ingestion/IngestionService.scala+++ b/memory-layer/src/main/scala/ix/memory/ingestion/IngestionService.scala@@ -5,7 +5,8 @@ import java.nio.file.{Files, Path}import cats.effect.IOimport cats.syntax.all._import ix.memory.db.{CommitResult, GraphQueryApi, GraphWriteApi}-import ix.memory.model.{PatchId, Rev}+import ix.memory.model.{NodeKind, PatchId, Rev}+import io.circe.Json/*** Orchestrates file ingestion: reads source files, parses them,@@ -18,26 +19,26 @@ class IngestionService(parserRouter: ParserRouter, writeApi: GraphWriteApi, quer*/def ingestFile(filePath: Path): IO[CommitResult] = {for {+ bytes <- IO.blocking(Files.readAllBytes(filePath))+ // Hash raw bytes so revisions are stable across encodings+ hash = Some(sha256Bytes(bytes))+ // Decode text with UTF-8, fallback to ISO-8859-1 to avoid hard failuressource <- IO.blocking {- val s = scala.io.Source.fromFile(filePath.toFile)- try s.mkString finally s.close()+ try new String(bytes, java.nio.charset.StandardCharsets.UTF_8)+ catch { case _: Throwable => new String(bytes, java.nio.charset.StandardCharsets.ISO_8859_1) }}- parser <- IO.fromOption(parserRouter.parserFor(filePath.toString))(- new IllegalArgumentException(s"No parser for: $filePath")- )- result = parser.parse(filePath.getFileName.toString, source)- hash = Some(- java.security.MessageDigest.getInstance("SHA-256")- .digest(source.getBytes("UTF-8"))- .map("%02x".format(_))- .mkString- )- // Check for existing patch from same source+extractor- extractor = if (filePath.toString.endsWith(".py")) "tree-sitter-python/1.0"- else if (filePath.toString.endsWith(".ts") || filePath.toString.endsWith(".tsx")) "typescript-parser/1.0"- else if (filePath.toString.endsWith(".json") || filePath.toString.endsWith(".yaml") || filePath.toString.endsWith(".yml") || filePath.toString.endsWith(".toml")) "config-parser/1.0"- else if (filePath.toString.endsWith(".md")) "markdown-parser/1.0"- else "unknown-parser/1.0"+ // Use the language-specific parser when available; otherwise fall back to generic text+ parserOpt = parserRouter.parserFor(filePath.toString)+ result = parserOpt match {+ case Some(p) => p.parse(filePath.getFileName.toString, source)+ case None => genericTextParse(filePath.getFileName.toString, source)+ }+ val fp = filePath.toString+ extractor = if (fp.endsWith(".py")) "tree-sitter-python/1.0"+ else if (fp.endsWith(".ts") || fp.endsWith(".tsx")) "typescript-parser/1.0"+ else if (fp.endsWith(".json") || fp.endsWith(".yaml") || fp.endsWith(".yml") || fp.endsWith(".toml") || fp.endsWith(".ini") || fp.endsWith(".conf") || fp.endsWith(".properties") || fp.endsWith(".env")) "config-parser/1.0"+ else if (fp.endsWith(".md") || fp.endsWith(".mdx") || fp.endsWith(".rst") || fp.endsWith(".txt")) "markdown-parser/1.0"+ else "text-parser/1.0"existing <- queryApi.getPatchesBySource(filePath.toString, extractor)prevPatch = existing.headOptionprevHash = prevPatch.flatMap(_.hcursor.downField("data").downField("source").get[String]("sourceHash").toOption)@@ -97,18 +98,50 @@ class IngestionService(parserRouter: ParserRouter, writeApi: GraphWriteApi, quercase Some("typescript") => Set(".ts", ".tsx")case Some("config") => Set(".json", ".yaml", ".yml", ".toml")case Some("markdown") => Set(".md")- case _ => Set(".py", ".ts", ".tsx", ".json", ".yaml", ".yml", ".toml", ".md") // all supported+ case _ => Set(+ // code+ ".py", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",+ ".java", ".scala", ".sc", ".go", ".rs", ".c", ".h", ".cc", ".cpp", ".hpp",+ ".kt", ".kts", ".swift", ".rb", ".php",++ // config / data+ ".json", ".yaml", ".yml", ".toml", ".ini", ".conf", ".env", ".properties",++ // docs+ ".md", ".mdx", ".rst", ".txt"+ )}if (Files.isRegularFile(path)) {- if (extensions.exists(ext => path.toString.endsWith(ext))) List(path)+ val base = path.getFileName.toString+ val isSpecial = Set(+ "Dockerfile",+ "Makefile",+ "README",+ "LICENSE",+ "NOTICE",+ "build.sbt"+ ).contains(base)+ if (isSpecial || extensions.exists(ext => base.endsWith(ext))) List(path)else List.empty} else if (Files.isDirectory(path)) {val stream = if (recursive) Files.walk(path) else Files.list(path)try {stream.iterator().asScala.filter(p => Files.isRegularFile(p))- .filter(p => extensions.exists(ext => p.toString.endsWith(ext)))+ .filter { p =>+ val base = p.getFileName.toString+ val isSpecial = Set(+ "Dockerfile",+ "Makefile",+ "README",+ "LICENSE",+ "NOTICE",+ "build.sbt"+ ).contains(base)+ val matchesExt = extensions.exists(ext => base.endsWith(ext))+ matchesExt || isSpecial+ }.toList} finally {stream.close()@@ -117,6 +150,33 @@ class IngestionService(parserRouter: ParserRouter, writeApi: GraphWriteApi, querList.empty}}++ private def sha256Bytes(bytes: Array[Byte]): String = {+ val md = java.security.MessageDigest.getInstance("SHA-256")+ md.digest(bytes).map("%02x".format(_)).mkString+ }++ /**+ * Generic fallback parse: ensures every text file produces at least a File entity with content.+ * This avoids needing a bespoke parser for every dev/text extension.+ */+ private def genericTextParse(fileName: String, source: String): ParseResult = {+ val lines = if (source.isEmpty) 1 else source.count(_ == '\n') + 1+ ParseResult(+ entities = Vector(+ ParsedEntity(+ name = fileName,+ kind = NodeKind.File,+ attrs = Map(+ "content" -> Json.fromString(source)+ ),+ lineStart = 1,+ lineEnd = lines+ )+ ),+ relationships = Vector.empty+ )+ }}case class IngestionResult(diff --git a/memory-layer/src/main/scala/ix/memory/ingestion/parsers/TypeScriptParser.scala b/memory-layer/src/main/scala/ix/memory/ingestion/parsers/TypeScriptParser.scalaindex 16752be1..7f0276a1 100644--- a/memory-layer/src/main/scala/ix/memory/ingestion/parsers/TypeScriptParser.scala+++ b/memory-layer/src/main/scala/ix/memory/ingestion/parsers/TypeScriptParser.scala@@ -57,7 +57,10 @@ class TypeScriptParser extends Parser {val fileEntity = ParsedEntity(name = fileName,kind = NodeKind.File,- attrs = Map("language" -> Json.fromString("typescript")),+ attrs = Map(+ "language" -> Json.fromString("typescript"),+ "content" -> Json.fromString(source)+ ),lineStart = 1,lineEnd = lines.length)diff --git a/memory-layer/src/main/scala/ix/memory/model/Claim.scala b/memory-layer/src/main/scala/ix/memory/model/Claim.scalaindex 46bfec32..64571d6b 100644--- a/memory-layer/src/main/scala/ix/memory/model/Claim.scala+++ b/memory-layer/src/main/scala/ix/memory/model/Claim.scala@@ -1,6 +1,6 @@package ix.memory.model-import io.circe.{Decoder, Encoder}+import io.circe.{Decoder, Encoder, Json}import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}sealed trait ClaimStatus@@ -30,6 +30,8 @@ final case class Claim(id: ClaimId,entityId: NodeId,statement: String,+ value: Json,+ confidence: Option[Double],status: ClaimStatus,provenance: Provenance,createdRev: Rev,diff --git a/memory-layer/src/main/scala/ix/memory/model/StructuredContext.scala b/memory-layer/src/main/scala/ix/memory/model/StructuredContext.scalaindex db06e91c..a4cf87f4 100644--- a/memory-layer/src/main/scala/ix/memory/model/StructuredContext.scala+++ b/memory-layer/src/main/scala/ix/memory/model/StructuredContext.scala@@ -67,17 +67,67 @@ object ContextMetadata {implicit val decoder: Decoder[ContextMetadata] = deriveDecoder[ContextMetadata]}+final case class NodeSummary(+ id: NodeId,+ kind: NodeKind,+ name: String,+ rev: Rev+)++object NodeSummary {+ implicit val encoder: Encoder[NodeSummary] = deriveEncoder[NodeSummary]+ implicit val decoder: Decoder[NodeSummary] = deriveDecoder[NodeSummary]+}++final case class EdgeSummary(+ id: EdgeId,+ src: NodeId,+ dst: NodeId,+ predicate: EdgePredicate,+ rev: Rev+)++object EdgeSummary {+ implicit val encoder: Encoder[EdgeSummary] = deriveEncoder[EdgeSummary]+ implicit val decoder: Decoder[EdgeSummary] = deriveDecoder[EdgeSummary]+}+final case class StructuredContext(- claims: List[ScoredClaim],- conflicts: List[ConflictReport],- decisions: List[DecisionReport],- intents: List[IntentReport],- nodes: List[GraphNode],- edges: List[GraphEdge],- metadata: ContextMetadata+ claims: List[ScoredClaim],+ conflicts: List[ConflictReport],+ decisions: List[DecisionReport],+ intents: List[IntentReport],+ nodes: List[GraphNode],+ edges: List[GraphEdge],+ nodeSummaries: List[NodeSummary] = Nil,+ edgeSummaries: List[EdgeSummary] = Nil,+ metadata: ContextMetadata)object StructuredContext {implicit val encoder: Encoder[StructuredContext] = deriveEncoder[StructuredContext]- implicit val decoder: Decoder[StructuredContext] = deriveDecoder[StructuredContext]++ implicit val decoder: Decoder[StructuredContext] = Decoder.instance { c =>+ for {+ claims <- c.getOrElse[List[ScoredClaim]]("claims")(Nil)+ conflicts <- c.getOrElse[List[ConflictReport]]("conflicts")(Nil)+ decisions <- c.getOrElse[List[DecisionReport]]("decisions")(Nil)+ intents <- c.getOrElse[List[IntentReport]]("intents")(Nil)+ nodes <- c.getOrElse[List[GraphNode]]("nodes")(Nil)+ edges <- c.getOrElse[List[GraphEdge]]("edges")(Nil)+ nodeSummaries <- c.getOrElse[List[NodeSummary]]("nodeSummaries")(Nil)+ edgeSummaries <- c.getOrElse[List[EdgeSummary]]("edgeSummaries")(Nil)+ metadata <- c.get[ContextMetadata]("metadata")+ } yield StructuredContext(+ claims = claims,+ conflicts = conflicts,+ decisions = decisions,+ intents = intents,+ nodes = nodes,+ edges = edges,+ nodeSummaries = nodeSummaries,+ edgeSummaries = edgeSummaries,+ metadata = metadata+ )+ }}