Skip to content

armgit / Ix

Public Imported from GitHub
0

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

feat: staleness detection compares file hashes to claim provenance

riley0227bf3d7ad4af83
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 9f92ebc4..7388b5e4 100644
--- a/memory-layer/src/main/scala/ix/memory/context/ContextService.scala
+++ b/memory-layer/src/main/scala/ix/memory/context/ContextService.scala
@@ -31,13 +31,16 @@ class ContextService(
allNodeIds = (seeds.map(_.id) ++ expanded.nodes.map(_.id)).distinct
claims <- claimCollector.collect(allNodeIds)
+ // 4.5. Detect stale sources
+ 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(
latestRev = rev,
- sourceChanged = false,
+ sourceChanged = stalenessMap.getOrElse(c.id, false),
corroboratingCount = corroborationMap.getOrElse(c.id, 0),
conflictState = ConflictState.NoConflict,
intentAlignment = IntentAlignment.NoConnection,
diff --git a/memory-layer/src/main/scala/ix/memory/context/StalenessDetector.scala b/memory-layer/src/main/scala/ix/memory/context/StalenessDetector.scala
new file mode 100644
index 00000000..83b56a4e
--- /dev/null
+++ b/memory-layer/src/main/scala/ix/memory/context/StalenessDetector.scala
@@ -0,0 +1,57 @@
+package ix.memory.context
+
+import java.nio.file.{Files, Paths}
+import java.security.MessageDigest
+
+import cats.effect.IO
+import ix.memory.model._
+
+/**
+ * Detects whether claims are stale by comparing the current source file hash
+ * to the hash recorded in the claim's provenance.
+ *
+ * A claim is "stale" if:
+ * - Its source file's current hash differs from provenance.sourceHash
+ * - Its source file no longer exists
+ * - Its provenance has no sourceHash (unknown state, treated as potentially stale)
+ */
+object StalenessDetector {
+
+ /**
+ * For a collection of claims, determine which have stale sources.
+ * Returns a Map from ClaimId to whether the source has changed.
+ *
+ * Uses IO since file system access is a side effect.
+ */
+ def detect(claims: Vector[Claim]): IO[Map[ClaimId, Boolean]] = IO.blocking {
+ // Group by sourceUri to avoid hashing the same file multiple times
+ val bySource = claims.groupBy(_.provenance.sourceUri)
+
+ bySource.flatMap { case (sourceUri, sourceClaims) =>
+ val currentHash = computeHash(sourceUri)
+ sourceClaims.map { claim =>
+ val changed = claim.provenance.sourceHash match {
+ case Some(recordedHash) => currentHash.fold(true)(_ != recordedHash) // file gone or hash differs
+ case None => false // no recorded hash, can't determine staleness -- treat as fresh
+ }
+ claim.id -> changed
+ }
+ }
+ }
+
+ /** Compute SHA-256 hash of a file, returning None if the file doesn't exist or can't be read. */
+ private def computeHash(sourceUri: String): Option[String] = {
+ try {
+ val path = Paths.get(sourceUri)
+ if (Files.exists(path) && Files.isRegularFile(path)) {
+ val bytes = Files.readAllBytes(path)
+ val digest = MessageDigest.getInstance("SHA-256")
+ Some(digest.digest(bytes).map("%02x".format(_)).mkString)
+ } else {
+ None // File doesn't exist
+ }
+ } catch {
+ case _: Exception => None // Can't read file
+ }
+ }
+}
diff --git a/memory-layer/src/test/scala/ix/memory/context/StalenessDetectorSpec.scala b/memory-layer/src/test/scala/ix/memory/context/StalenessDetectorSpec.scala
new file mode 100644
index 00000000..79ed29d8
--- /dev/null
+++ b/memory-layer/src/test/scala/ix/memory/context/StalenessDetectorSpec.scala
@@ -0,0 +1,120 @@
+package ix.memory.context
+
+import java.nio.file.{Files, Path}
+import java.security.MessageDigest
+import java.time.Instant
+import java.util.UUID
+
+import cats.effect.IO
+import cats.effect.testing.scalatest.AsyncIOSpec
+import org.scalatest.flatspec.AsyncFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+import ix.memory.model._
+
+class StalenessDetectorSpec extends AsyncFlatSpec with AsyncIOSpec with Matchers {
+
+ private def hashOf(content: String): String =
+ MessageDigest.getInstance("SHA-256")
+ .digest(content.getBytes("UTF-8"))
+ .map("%02x".format(_))
+ .mkString
+
+ private def makeClaim(sourceUri: String, sourceHash: Option[String]): Claim =
+ Claim(
+ id = ClaimId(UUID.randomUUID()),
+ entityId = NodeId(UUID.randomUUID()),
+ statement = "test claim",
+ status = ClaimStatus.Active,
+ provenance = Provenance(sourceUri, sourceHash, "test", SourceType.Code, Instant.now()),
+ createdRev = Rev(1L),
+ deletedRev = None
+ )
+
+ // Test 1: File unchanged -- not stale
+ "StalenessDetector" should "return false when file hash matches" in {
+ val tmpFile = Files.createTempFile("staleness-test-", ".txt")
+ Files.writeString(tmpFile, "hello world")
+ val hash = hashOf("hello world")
+ val claim = makeClaim(tmpFile.toString, Some(hash))
+
+ StalenessDetector.detect(Vector(claim)).map { result =>
+ result(claim.id) shouldBe false
+ Files.deleteIfExists(tmpFile)
+ succeed
+ }
+ }
+
+ // Test 2: File changed -- stale
+ it should "return true when file hash differs" in {
+ val tmpFile = Files.createTempFile("staleness-test-", ".txt")
+ Files.writeString(tmpFile, "updated content")
+ val oldHash = hashOf("original content")
+ val claim = makeClaim(tmpFile.toString, Some(oldHash))
+
+ StalenessDetector.detect(Vector(claim)).map { result =>
+ result(claim.id) shouldBe true
+ Files.deleteIfExists(tmpFile)
+ succeed
+ }
+ }
+
+ // Test 3: File doesn't exist -- stale
+ it should "return true when file no longer exists" in {
+ val claim = makeClaim("/nonexistent/path/to/file.py", Some("abc123"))
+
+ StalenessDetector.detect(Vector(claim)).map { result =>
+ result(claim.id) shouldBe true
+ }
+ }
+
+ // Test 4: No source hash recorded -- treat as fresh
+ it should "return false when no source hash is recorded" in {
+ val claim = makeClaim("/some/path.py", None)
+
+ StalenessDetector.detect(Vector(claim)).map { result =>
+ result(claim.id) shouldBe false
+ }
+ }
+
+ // Test 5: Multiple claims from same file -- efficient (single hash)
+ it should "handle multiple claims from the same source efficiently" in {
+ val tmpFile = Files.createTempFile("staleness-test-", ".txt")
+ Files.writeString(tmpFile, "content")
+ val hash = hashOf("content")
+ val c1 = makeClaim(tmpFile.toString, Some(hash))
+ val c2 = makeClaim(tmpFile.toString, Some(hash))
+
+ StalenessDetector.detect(Vector(c1, c2)).map { result =>
+ result(c1.id) shouldBe false
+ result(c2.id) shouldBe false
+ Files.deleteIfExists(tmpFile)
+ succeed
+ }
+ }
+
+ // Test 6: Empty claims
+ it should "return empty map for no claims" in {
+ StalenessDetector.detect(Vector.empty).map { result =>
+ result shouldBe empty
+ }
+ }
+
+ // Test 7: Mix of stale and fresh
+ it should "handle mix of stale and fresh claims" in {
+ val tmpFile = Files.createTempFile("staleness-test-", ".txt")
+ Files.writeString(tmpFile, "current content")
+ val correctHash = hashOf("current content")
+ val wrongHash = hashOf("old content")
+
+ val fresh = makeClaim(tmpFile.toString, Some(correctHash))
+ val stale = makeClaim(tmpFile.toString, Some(wrongHash))
+
+ StalenessDetector.detect(Vector(fresh, stale)).map { result =>
+ result(fresh.id) shouldBe false
+ result(stale.id) shouldBe true
+ Files.deleteIfExists(tmpFile)
+ succeed
+ }
+ }
+}