Skip to content

armgit / Ix

Public Imported from GitHub
0

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

feat: 8-step context pipeline — relevance scoring, edge priority, intent/decision collection

riley02271b9c34f97883
diff --git a/memory-layer/src/main/scala/ix/memory/context/ConfidenceScorer.scala b/memory-layer/src/main/scala/ix/memory/context/ConfidenceScorer.scala
index 7225c291..62b4b66b 100644
--- a/memory-layer/src/main/scala/ix/memory/context/ConfidenceScorer.scala
+++ b/memory-layer/src/main/scala/ix/memory/context/ConfidenceScorer.scala
@@ -48,7 +48,8 @@ class ConfidenceScorerImpl extends ConfidenceScorer {
val conflict = computeConflictPenalty(ctx.conflictState)
val intent = computeIntentAlignment(ctx.intentAlignment)
- ScoredClaim(claim, ConfidenceBreakdown(base, verif, recency, corr, conflict, intent))
+ val breakdown = ConfidenceBreakdown(base, verif, recency, corr, conflict, intent)
+ ScoredClaim(claim, breakdown, relevance = 1.0, finalScore = breakdown.score)
}
private def computeRecency(ctx: ScoringContext): Factor = {
diff --git a/memory-layer/src/main/scala/ix/memory/context/ContextRanker.scala b/memory-layer/src/main/scala/ix/memory/context/ContextRanker.scala
index 1d639146..c570b9e6 100644
--- a/memory-layer/src/main/scala/ix/memory/context/ContextRanker.scala
+++ b/memory-layer/src/main/scala/ix/memory/context/ContextRanker.scala
@@ -5,5 +5,5 @@ import ix.memory.model.ScoredClaim
object ContextRanker {
def rank(claims: Vector[ScoredClaim]): Vector[ScoredClaim] =
- claims.sortBy(-_.confidence.score)
+ claims.sortBy(sc => -sc.finalScore)
}
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 3a8e5399..0203b39a 100644
--- a/memory-layer/src/main/scala/ix/memory/context/ContextService.scala
+++ b/memory-layer/src/main/scala/ix/memory/context/ContextService.scala
@@ -15,7 +15,8 @@ class ContextService(
) {
def query(question: String,
- asOfRev: Option[Rev] = None): IO[StructuredContext] =
+ asOfRev: Option[Rev] = None,
+ depth: Option[String] = None): IO[StructuredContext] =
for {
// 1. Extract entity keywords from the natural language query
terms <- IO.pure(EntityExtractor.extract(question))
@@ -23,21 +24,21 @@ class ContextService(
// 2. Seed: search the graph for nodes matching extracted terms
seeds <- seeder.seed(terms, asOfRev)
- // 3. Expand: traverse the graph 1 hop from each seed
+ // 3. Expand: traverse the graph 1 hop from each seed (with edge priority)
expanded <- expander.expand(seeds.map(_.id), hops = 1, asOfRev = asOfRev)
// 4. Collect claims for all discovered nodes
allNodeIds = (seeds.map(_.id) ++ expanded.nodes.map(_.id)).distinct
claims <- claimCollector.collect(allNodeIds)
- // 5. Score each claim
+ // 5. Score each claim for confidence
rev <- asOfRev.fold(queryApi.getLatestRev)(IO.pure)
scored = claims.map { c =>
confidenceScorer.score(c, ScoringContext(
latestRev = rev,
- sourceChanged = false, // Default for Phase 1
- corroboratingCount = 1, // Default for Phase 1
- conflictState = ConflictState.NoConflict, // Default for Phase 1
+ sourceChanged = false,
+ corroboratingCount = 1,
+ conflictState = ConflictState.NoConflict,
intentAlignment = IntentAlignment.NoConnection,
observedAt = c.provenance.observedAt
))
@@ -46,23 +47,50 @@ class ContextService(
// 6. Detect conflicts among scored claims
conflicts = conflictDetector.detect(scored)
- // 7. Rank claims by confidence (descending)
- ranked = ContextRanker.rank(scored)
+ // 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. Assemble and return StructuredContext
} yield StructuredContext(
claims = ranked.toList,
conflicts = conflicts.toList,
- decisions = List.empty,
- intents = List.empty,
- nodes = (seeds ++ expanded.nodes).distinctBy(_.id).toList,
+ decisions = decisions.toList,
+ intents = intents.toList,
+ nodes = allNodes.toList,
edges = expanded.edges.toList,
metadata = ContextMetadata(
query = question,
seedEntities = seeds.map(_.id).toList,
hopsExpanded = 1,
asOfRev = rev,
- depth = None
+ depth = depth.orElse(Some("standard"))
)
)
+
+ private def toDecisionReport(node: GraphNode, rev: Rev): DecisionReport =
+ DecisionReport(
+ title = node.attrs.hcursor.get[String]("title").getOrElse(node.id.value.toString),
+ rationale = node.attrs.hcursor.get[String]("rationale").getOrElse(""),
+ entityId = Some(node.id),
+ intentId = node.attrs.hcursor.get[String]("intent_id").toOption.flatMap(s =>
+ scala.util.Try(java.util.UUID.fromString(s)).toOption.map(NodeId(_))
+ ),
+ rev = rev
+ )
+
+ private def toIntentReport(node: GraphNode): IntentReport =
+ IntentReport(
+ id = node.id,
+ statement = node.attrs.hcursor.get[String]("statement").getOrElse(""),
+ status = node.attrs.hcursor.get[String]("status").getOrElse("active"),
+ confidence = node.attrs.hcursor.get[Double]("confidence").getOrElse(1.0),
+ parentIntent = node.attrs.hcursor.get[String]("parent_intent").toOption
+ )
}
diff --git a/memory-layer/src/main/scala/ix/memory/context/GraphExpander.scala b/memory-layer/src/main/scala/ix/memory/context/GraphExpander.scala
index 8c712aff..346d8b39 100644
--- a/memory-layer/src/main/scala/ix/memory/context/GraphExpander.scala
+++ b/memory-layer/src/main/scala/ix/memory/context/GraphExpander.scala
@@ -8,6 +8,10 @@ import ix.memory.model._
class GraphExpander(queryApi: GraphQueryApi) {
+ /** Low-priority edge predicates — skipped at hop 2+ to focus expansion. */
+ private val lowPriorityPredicates: Set[String] =
+ Set("mentioned_in", "changed_with", "same_as")
+
def expand(seeds: Vector[NodeId], hops: Int = 1,
predicates: Option[Set[String]] = None,
asOfRev: Option[Rev] = None): IO[ExpandResult] =
@@ -18,6 +22,11 @@ class GraphExpander(queryApi: GraphQueryApi) {
.map { results =>
val allNodes = results.flatMap(_.nodes).distinctBy(_.id)
val allEdges = results.flatMap(_.edges).distinctBy(_.id)
- ExpandResult(allNodes, allEdges)
+ // Filter out low-priority edges when expanding beyond 1 hop
+ val filteredEdges = if (hops > 1)
+ allEdges.filterNot(e => lowPriorityPredicates.contains(e.predicate.value.toLowerCase))
+ else
+ allEdges
+ ExpandResult(allNodes, filteredEdges)
}
}
diff --git a/memory-layer/src/main/scala/ix/memory/context/RelevanceScorer.scala b/memory-layer/src/main/scala/ix/memory/context/RelevanceScorer.scala
new file mode 100644
index 00000000..4fc04e2d
--- /dev/null
+++ b/memory-layer/src/main/scala/ix/memory/context/RelevanceScorer.scala
@@ -0,0 +1,22 @@
+package ix.memory.context
+
+import ix.memory.model._
+
+object RelevanceScorer {
+ def score(
+ claims: Vector[ScoredClaim],
+ seedNodeIds: Set[NodeId],
+ expandedEdges: Vector[GraphEdge]
+ ): Vector[ScoredClaim] = {
+ val oneHopIds = expandedEdges
+ .flatMap(e => Vector(e.src, e.dst))
+ .toSet -- seedNodeIds
+
+ claims.map { sc =>
+ val relevance = if (seedNodeIds.contains(sc.claim.entityId)) 1.0
+ else if (oneHopIds.contains(sc.claim.entityId)) 0.7
+ else 0.4
+ sc.copy(relevance = relevance, finalScore = relevance * sc.confidence.score)
+ }
+ }
+}
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 be8b5ebf..db06e91c 100644
--- a/memory-layer/src/main/scala/ix/memory/model/StructuredContext.scala
+++ b/memory-layer/src/main/scala/ix/memory/model/StructuredContext.scala
@@ -5,7 +5,9 @@ import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
final case class ScoredClaim(
claim: Claim,
- confidence: ConfidenceBreakdown
+ confidence: ConfidenceBreakdown,
+ relevance: Double = 1.0,
+ finalScore: Double = 0.0
)
object ScoredClaim {
diff --git a/memory-layer/src/test/scala/ix/memory/context/ContextServiceSpec.scala b/memory-layer/src/test/scala/ix/memory/context/ContextServiceSpec.scala
index 791f20db..2360da61 100644
--- a/memory-layer/src/test/scala/ix/memory/context/ContextServiceSpec.scala
+++ b/memory-layer/src/test/scala/ix/memory/context/ContextServiceSpec.scala
@@ -81,6 +81,7 @@ class ContextServiceSpec extends AsyncFlatSpec with AsyncIOSpec with Matchers {
// seedEntities is List[NodeId] — verify at least 1 seed was found
result.metadata.seedEntities should not be empty
result.metadata.hopsExpanded shouldBe 1
+ result.metadata.depth shouldBe Some("standard")
}
}
}
@@ -137,12 +138,16 @@ class ContextServiceSpec extends AsyncFlatSpec with AsyncIOSpec with Matchers {
result <- contextService.query("What does billing do?")
} yield {
result.claims should not be empty
- // All claims should have a score > 0
+ // All claims should have a confidence score > 0
result.claims.foreach { sc =>
sc.confidence.score should be > 0.0
}
- // Claims should be sorted descending by score
- val scores = result.claims.map(_.confidence.score)
+ // Claims should have finalScore > 0
+ result.claims.foreach { sc =>
+ sc.finalScore should be > 0.0
+ }
+ // Claims should be sorted descending by finalScore
+ val scores = result.claims.map(_.finalScore)
scores shouldBe scores.sorted.reverse
}
}
@@ -219,12 +224,12 @@ class ContextServiceSpec extends AsyncFlatSpec with AsyncIOSpec with Matchers {
val scored1 = ScoredClaim(claim1, ConfidenceBreakdown(
Factor(0.5, "low"), Factor(1.0, "ok"), Factor(1.0, "ok"), Factor(1.0, "ok"), Factor(1.0, "ok"), Factor(1.0, "ok")
- ))
+ ), relevance = 1.0, finalScore = 0.5)
val scored2 = ScoredClaim(claim2, ConfidenceBreakdown(
Factor(0.9, "high"), Factor(1.0, "ok"), Factor(1.0, "ok"), Factor(1.0, "ok"), Factor(1.0, "ok"), Factor(1.0, "ok")
- ))
+ ), relevance = 1.0, finalScore = 0.9)
val ranked = ContextRanker.rank(Vector(scored1, scored2))
- ranked.head.confidence.score should be > ranked.last.confidence.score
+ ranked.head.finalScore should be > ranked.last.finalScore
}
}
diff --git a/memory-layer/src/test/scala/ix/memory/context/RelevanceScorerSpec.scala b/memory-layer/src/test/scala/ix/memory/context/RelevanceScorerSpec.scala
new file mode 100644
index 00000000..11ab9e66
--- /dev/null
+++ b/memory-layer/src/test/scala/ix/memory/context/RelevanceScorerSpec.scala
@@ -0,0 +1,80 @@
+package ix.memory.context
+
+import java.time.Instant
+import java.util.UUID
+
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+import ix.memory.model._
+
+class RelevanceScorerSpec extends AnyFlatSpec with Matchers {
+
+ private val prov = Provenance("test://uri", None, "test", SourceType.Code, Instant.now())
+ private val defaultBreakdown = ConfidenceBreakdown(
+ Factor(0.8, "ok"), Factor(1.0, "ok"), Factor(1.0, "ok"),
+ Factor(1.0, "ok"), Factor(1.0, "ok"), Factor(1.0, "ok")
+ )
+
+ private def makeClaim(entityId: NodeId): ScoredClaim = {
+ val claim = Claim(
+ ClaimId(UUID.randomUUID()), entityId, "test_field",
+ ClaimStatus.Active, prov, Rev(1L), None
+ )
+ ScoredClaim(claim, defaultBreakdown, relevance = 1.0, finalScore = defaultBreakdown.score)
+ }
+
+ "RelevanceScorer" should "assign relevance 1.0 to seed node claims" in {
+ val seedId = NodeId(UUID.randomUUID())
+ val claims = Vector(makeClaim(seedId))
+ val result = RelevanceScorer.score(claims, Set(seedId), Vector.empty)
+ result.head.relevance shouldBe 1.0
+ result.head.finalScore shouldBe (1.0 * defaultBreakdown.score)
+ }
+
+ it should "assign relevance 0.7 to one-hop node claims" in {
+ val seedId = NodeId(UUID.randomUUID())
+ val oneHopId = NodeId(UUID.randomUUID())
+ val edge = GraphEdge(
+ id = EdgeId(UUID.randomUUID()),
+ src = seedId, dst = oneHopId,
+ predicate = EdgePredicate("calls"),
+ attrs = io.circe.Json.obj(),
+ provenance = prov,
+ createdRev = Rev(1L), deletedRev = None
+ )
+ val claims = Vector(makeClaim(oneHopId))
+ val result = RelevanceScorer.score(claims, Set(seedId), Vector(edge))
+ result.head.relevance shouldBe 0.7
+ result.head.finalScore shouldBe (0.7 * defaultBreakdown.score +- 0.001)
+ }
+
+ it should "assign relevance 0.4 to two-hop-plus node claims" in {
+ val seedId = NodeId(UUID.randomUUID())
+ val farId = NodeId(UUID.randomUUID())
+ val claims = Vector(makeClaim(farId))
+ val result = RelevanceScorer.score(claims, Set(seedId), Vector.empty)
+ result.head.relevance shouldBe 0.4
+ result.head.finalScore shouldBe (0.4 * defaultBreakdown.score +- 0.001)
+ }
+
+ it should "handle mixed claims correctly" in {
+ val seedId = NodeId(UUID.randomUUID())
+ val oneHopId = NodeId(UUID.randomUUID())
+ val farId = NodeId(UUID.randomUUID())
+ val edge = GraphEdge(
+ id = EdgeId(UUID.randomUUID()),
+ src = seedId, dst = oneHopId,
+ predicate = EdgePredicate("calls"),
+ attrs = io.circe.Json.obj(),
+ provenance = prov,
+ createdRev = Rev(1L), deletedRev = None
+ )
+ val claims = Vector(makeClaim(seedId), makeClaim(oneHopId), makeClaim(farId))
+ val result = RelevanceScorer.score(claims, Set(seedId), Vector(edge))
+
+ result(0).relevance shouldBe 1.0
+ result(1).relevance shouldBe 0.7
+ result(2).relevance shouldBe 0.4
+ }
+}