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
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.scalaindex 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)).distinctclaims <- claimCollector.collect(allNodeIds)+ // 4.5. Detect stale sources+ stalenessMap <- StalenessDetector.detect(claims)+// 5. Score each claim for confidencerev <- 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.scalanew file mode 100644index 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.scalanew file mode 100644index 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+ }+ }+}