Skip to content

armgit / Ix

Public Imported from GitHub
0

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

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.yml
index 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: 5
memory-layer:
build: ./memory-layer
@@ -28,8 +22,7 @@ services:
ARANGO_PASSWORD: ""
PORT: "8090"
depends_on:
- arangodb:
- condition: service_healthy
+ - arangodb
healthcheck:
test: ["CMD", "curl", "-sf", "http://localhost:8090/v1/health"]
interval: 10s
diff --git a/ix-cli/src/client/api.ts b/ix-cli/src/client/api.ts
index 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.scala
index 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.ContextService
import 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.scala
index 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 ConflictDe
if (activeClaims.size < 2) Vector.empty
else {
- 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.empty
else {
- 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.scala
index 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 query
terms <- 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 seeds
relevant = RelevanceScorer.score(scored, seeds.map(_.id).toSet, expanded.edges)
// 8. Rank claims by finalScore (relevance x confidence) descending
ranked = 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.scala
index 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").toOption
statusStr <- c.get[String]("status").toOption
status <- 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.scala
index 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.scala
index 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.IO
import 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 failures
source <- 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.headOption
prevHash = prevPatch.flatMap(_.hcursor.downField("data").downField("source").get[String]("sourceHash").toOption)
@@ -97,18 +98,50 @@ class IngestionService(parserRouter: ParserRouter, writeApi: GraphWriteApi, quer
case 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, quer
List.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.scala
index 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.scala
index 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.scala
index 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
+ )
+ }
}