Skip to content

armgit / Ix

Public Imported from GitHub
0

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

feat: add CompactConfidence model with trivial-factor collapsing

riley0227f17ac0427bbc
diff --git a/memory-layer/src/main/scala/ix/memory/model/ConfidenceBreakdown.scala b/memory-layer/src/main/scala/ix/memory/model/ConfidenceBreakdown.scala
index d8ade7e1..e3f9bf3c 100644
--- a/memory-layer/src/main/scala/ix/memory/model/ConfidenceBreakdown.scala
+++ b/memory-layer/src/main/scala/ix/memory/model/ConfidenceBreakdown.scala
@@ -1,7 +1,8 @@
package ix.memory.model
-import io.circe.{Decoder, Encoder}
+import io.circe.{Decoder, Encoder, Json}
import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
+import io.circe.syntax._
final case class Factor(value: Double, reason: String)
@@ -10,6 +11,39 @@ object Factor {
implicit val decoder: Decoder[Factor] = deriveDecoder[Factor]
}
+final case class CompactConfidence(
+ score: Double,
+ authority: Option[Double],
+ nonTrivialFactors: List[(String, Factor)]
+)
+
+object CompactConfidence {
+
+ def isTrivial(f: Factor): Boolean = f.value >= 0.99 && f.value <= 1.01
+
+ implicit val encoder: Encoder[CompactConfidence] = Encoder.instance { cc =>
+ val base = List("score" -> Json.fromDoubleOrNull(cc.score))
+
+ val auth = cc.authority.map(a => "authority" -> Json.fromDoubleOrNull(a)).toList
+
+ val factors = if (cc.nonTrivialFactors.nonEmpty) {
+ val obj = Json.obj(cc.nonTrivialFactors.map { case (name, factor) =>
+ name -> factor.asJson
+ }: _*)
+ List("factors" -> obj)
+ } else Nil
+
+ Json.obj((base ++ auth ++ factors): _*)
+ }
+
+ implicit val decoder: Decoder[CompactConfidence] = Decoder.instance { c =>
+ for {
+ score <- c.downField("score").as[Double]
+ authority <- c.downField("authority").as[Option[Double]]
+ } yield CompactConfidence(score, authority, Nil)
+ }
+}
+
final case class ConfidenceBreakdown(
baseAuthority: Factor,
verification: Factor,
@@ -29,6 +63,23 @@ final case class ConfidenceBreakdown(
intentAlignment.value
math.max(0.0, math.min(1.0, raw))
}
+
+ /** Collapse trivial (≈1.0) multipliers into a compact representation. */
+ def toCompact: CompactConfidence = {
+ val candidates = List(
+ "verification" -> verification,
+ "recency" -> recency,
+ "corroboration" -> corroboration,
+ "conflictPenalty" -> conflictPenalty,
+ "intentAlignment" -> intentAlignment
+ )
+ val nonTrivial = candidates.filterNot { case (_, f) => CompactConfidence.isTrivial(f) }
+ CompactConfidence(
+ score = score,
+ authority = Some(baseAuthority.value),
+ nonTrivialFactors = nonTrivial
+ )
+ }
}
object ConfidenceBreakdown {
diff --git a/memory-layer/src/test/scala/ix/memory/model/ModelSpec.scala b/memory-layer/src/test/scala/ix/memory/model/ModelSpec.scala
index b86961b6..3e233ddf 100644
--- a/memory-layer/src/test/scala/ix/memory/model/ModelSpec.scala
+++ b/memory-layer/src/test/scala/ix/memory/model/ModelSpec.scala
@@ -248,4 +248,34 @@ class ModelSpec extends AnyFlatSpec with Matchers {
val decoded = decode[ConfidenceBreakdown](json.noSpaces)
decoded shouldBe Right(breakdown)
}
+
+ it should "produce compact confidence when all multipliers are trivial" in {
+ val trivial = ConfidenceBreakdown(
+ baseAuthority = Factor(0.9, "Code, tree-sitter-python/1.0"),
+ verification = Factor(1.0, "no verification data available"),
+ recency = Factor(1.0, "Source unchanged since observation"),
+ corroboration = Factor(1.0, "0 corroborating sources"),
+ conflictPenalty = Factor(1.0, "no conflicts"),
+ intentAlignment = Factor(1.0, "No connection to intent")
+ )
+ val compact = trivial.toCompact
+ compact.score shouldBe trivial.score
+ compact.authority shouldBe Some(0.9)
+ compact.nonTrivialFactors shouldBe empty
+ }
+
+ it should "include non-trivial factors in compact confidence" in {
+ val interesting = ConfidenceBreakdown(
+ baseAuthority = Factor(0.9, "Code, tree-sitter-python/1.0"),
+ verification = Factor(1.0, "no verification data available"),
+ recency = Factor(0.7, "1-6 months since observation"),
+ corroboration = Factor(1.1, "3 corroborating sources"),
+ conflictPenalty = Factor(1.0, "no conflicts"),
+ intentAlignment = Factor(1.0, "No connection to intent")
+ )
+ val compact = interesting.toCompact
+ compact.score shouldBe interesting.score
+ compact.nonTrivialFactors should have size 2
+ compact.nonTrivialFactors.map(_._1) should contain allOf ("recency", "corroboration")
+ }
}