Your phone, on your command. Gotcha is world's first fully on-device AI copilot for Android that turns natural language into real device actions — safely.
package com.gotcha.data
import com.gotcha.llm.ChatMessage
import kotlinx.serialization.json.JsonPrimitive
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import java.io.File
import java.nio.file.Files
@Suppress("LargeClass")
class MemoryStoreTest {
private lateinit var tmpRoot: File
private var savedOverride: String? = null
@Before
fun setUp() {
tmpRoot = Files.createTempDirectory("gotcha-memory-test").toFile()
savedOverride = try {
GotchaStorage.rootPath
} catch (_: Exception) {
null
}
GotchaStorage.rootPath = File(tmpRoot, "Gotcha").absolutePath
}
@After
fun tearDown() {
tmpRoot.deleteRecursively()
if (savedOverride != null) {
GotchaStorage.rootPath = savedOverride!!
} else {
GotchaStorage.resetRootPathForTests()
}
}
@Test
fun `ensureDefaults creates memory tree and seeds files`() {
MemoryStore.ensureDefaults(Settings(userName = "Ada"))
assertTrue(GotchaStorage.memoryRoot().isDirectory)
assertTrue(GotchaStorage.soulFile().exists())
assertTrue(GotchaStorage.memoryIndexFile().exists())
assertTrue(GotchaStorage.memoryUserFile().readText().contains("Ada"))
assertTrue(File(GotchaStorage.memoryAreasDir(), "work.md").exists())
}
@Test
fun `startup message contains capped soul and memory index`() {
MemoryStore.ensureDefaults(Settings())
GotchaStorage.soulFile().writeText("S".repeat(2000))
val msg = MemoryStore.buildStartupMessage()
assertNotNull(msg)
val text = msg!!.textContent
assertTrue(text.contains(MemoryStore.STARTUP_MARKER))
assertTrue(text.contains("truncated"))
assertTrue(MemoryStore.isStartupMessage(msg))
}
@Test
fun `startup message null when files missing`() {
assertNull(MemoryStore.buildStartupMessage())
}
@Test
fun `non startup message is not detected`() {
val other = ChatMessage(role = "system", content = JsonPrimitive("hello"))
assertFalse(MemoryStore.isStartupMessage(other))
}
@Test
fun `pointer block is stable and cheap`() {
val first = MemoryStore.buildMemoryPointerBlock()
val second = MemoryStore.buildMemoryPointerBlock()
assertTrue(first == second)
assertTrue(first.contains("<memory>"))
assertTrue(first.length < 800)
}
@Test
fun `syncUserFile reflects profile changes`() {
MemoryStore.ensureDefaults(Settings(userName = "Ada"))
MemoryStore.syncUserFile(Settings(userName = "Grace", userOccupation = "Engineer"))
val text = GotchaStorage.memoryUserFile().readText()
assertTrue(text.contains("Grace"))
assertFalse(text.contains("Ada"))
}
@Test
fun `user file includes reply style`() {
MemoryStore.syncUserFile(Settings(userResponseStyle = "No bullet lists."))
assertTrue(GotchaStorage.memoryUserFile().readText().contains("No bullet lists."))
}
@Test
fun `startup message uses absolute paths`() {
MemoryStore.ensureDefaults(Settings())
val text = MemoryStore.buildStartupMessage()!!.textContent
assertTrue(text.contains(GotchaStorage.memoryRoot().absolutePath))
assertFalse(text.contains("Paths:\n Gotcha/memory/"))
}
@Test
fun `pointer block is conditional on availability`() {
val pointer = MemoryStore.buildMemoryPointerBlock()
assertTrue(pointer.contains("if that message is absent"))
assertTrue(pointer.contains("ABSOLUTE paths"))
}
@Test
fun `snapshot loads seeded files`() {
MemoryStore.ensureDefaults(Settings(userName = "Ada"))
val snap = MemoryStore.loadSnapshot()
assertTrue(snap.available)
assertNotNull(snap.soul)
assertNotNull(snap.memoryIndex)
assertTrue(snap.userCard!!.content.contains("Ada"))
assertTrue(snap.areas.map { it.name }.contains("work.md"))
}
@Test
fun `snapshot unavailable when files missing`() {
val snap = MemoryStore.loadSnapshot()
assertFalse(snap.available)
assertNull(snap.soul)
assertTrue(snap.areas.isEmpty())
}
@Test
fun `wiki links parse with labels and dedupe`() {
val links = MemoryStore.parseWikiLinks(
"See [[notes/trip.md]] and [[people/asha.md| Asha ]] and [[notes/trip.md]]."
)
assertEquals(listOf("notes/trip.md", "people/asha.md"), links)
}
@Test
fun `graph resolves links and skips dangling ones`() {
MemoryStore.ensureDefaults(Settings())
GotchaStorage.memoryNotesDir().mkdirs()
File(GotchaStorage.memoryNotesDir(), "trip.md").writeText("Trip. See [[work]] and [[nowhere]].")
val snap = MemoryStore.loadSnapshot()
val graph = MemoryStore.buildGraph(snap)
assertTrue(graph.nodes.map { it.id }.contains("notes/trip.md"))
val edge = graph.edges.singleOrNull { it.fromId == "notes/trip.md" }
assertNotNull(edge)
assertEquals("areas/work.md", edge!!.toId)
}
@Test
fun `bare links prefer the source directory`() {
MemoryStore.ensureDefaults(Settings())
GotchaStorage.memoryNotesDir().mkdirs()
GotchaStorage.memoryPeopleDir().mkdirs()
File(GotchaStorage.memoryNotesDir(), "plan.md").writeText("Note plan.")
File(GotchaStorage.memoryPeopleDir(), "plan.md").writeText("Person plan.")
File(GotchaStorage.memoryNotesDir(), "trip.md").writeText("Trip. See [[plan]].")
val snap = MemoryStore.loadSnapshot()
val graph = MemoryStore.buildGraph(snap)
val edge = graph.edges.singleOrNull { it.fromId == "notes/trip.md" }
assertNotNull(edge)
assertEquals("notes/plan.md", edge!!.toId)
}
@Test
fun `ambiguous bare names draw no edge`() {
MemoryStore.ensureDefaults(Settings())
GotchaStorage.memoryNotesDir().mkdirs()
GotchaStorage.memoryPeopleDir().mkdirs()
File(GotchaStorage.memoryNotesDir(), "plan.md").writeText("Note plan.")
File(GotchaStorage.memoryPeopleDir(), "plan.md").writeText("Person plan.")
File(GotchaStorage.memoryAreasDir(), "hub.md").writeText("Hub. See [[plan]].")
val snap = MemoryStore.loadSnapshot()
val graph = MemoryStore.buildGraph(snap)
assertTrue(graph.edges.none { it.fromId == "areas/hub.md" })
}
@Test
fun `startup read stays bounded on huge files`() {
MemoryStore.ensureDefaults(Settings())
val big = "y".repeat(2_000_000)
GotchaStorage.soulFile().writeText(big)
val capped = MemoryStore.readCapped(GotchaStorage.soulFile(), MemoryStore.SOUL_CAP_CHARS)
assertNotNull(capped)
assertTrue(capped!!.truncated)
assertTrue(capped.text.length <= MemoryStore.SOUL_CAP_CHARS)
}
@Test
fun `graph keeps same-named files apart`() {
MemoryStore.ensureDefaults(Settings())
GotchaStorage.memoryNotesDir().mkdirs()
GotchaStorage.memoryPeopleDir().mkdirs()
File(GotchaStorage.memoryNotesDir(), "plan.md").writeText("Plan. See [[people/plan]].")
File(GotchaStorage.memoryPeopleDir(), "plan.md").writeText("Person.")
val snap = MemoryStore.loadSnapshot()
val graph = MemoryStore.buildGraph(snap)
assertTrue(graph.nodes.map { it.id }.contains("notes/plan.md"))
assertTrue(graph.nodes.map { it.id }.contains("people/plan.md"))
val edge = graph.edges.singleOrNull { it.fromId == "notes/plan.md" }
assertNotNull(edge)
assertEquals("people/plan.md", edge!!.toId)
}
@Test
fun `graph sees links past the preview cap`() {
MemoryStore.ensureDefaults(Settings())
GotchaStorage.memoryNotesDir().mkdirs()
val filler = "x".repeat(MemoryStore.VIEWER_FILE_CAP_CHARS + 100)
File(GotchaStorage.memoryNotesDir(), "long.md").writeText("$filler [[work]]")
val snap = MemoryStore.loadSnapshot()
assertTrue(snap.notes.single { it.name == "long.md" }.truncated)
val graph = MemoryStore.buildGraph(snap)
assertTrue(graph.edges.any { it.fromId == "notes/long.md" && it.toId == "areas/work.md" })
}
@Test
fun `markdown extension renders as markdown and links`() {
MemoryStore.ensureDefaults(Settings())
val rawDir = GotchaStorage.memoryRawDir()
rawDir.mkdirs()
File(rawDir, "ref.markdown").writeText("Ref. See [[work]].")
val snap = MemoryStore.loadSnapshot()
val ref = snap.raw.single { it.name == "ref.markdown" }
assertTrue(ref.isMarkdown)
val graph = MemoryStore.buildGraph(snap)
assertTrue(graph.edges.any { it.fromId == "raw/ref.markdown" && it.toId == "areas/work.md" })
}
@Test
fun `raw files list any extension without content`() {
MemoryStore.ensureDefaults(Settings())
val rawDir = GotchaStorage.memoryRawDir()
rawDir.mkdirs()
File(rawDir, "memo.mp3").writeBytes(byteArrayOf(1, 2, 3, 4))
File(rawDir, "note.txt").writeText("hello raw")
val snap = MemoryStore.loadSnapshot()
val mp3 = snap.raw.single { it.name == "memo.mp3" }
assertEquals("", mp3.content)
assertEquals(4L, mp3.sizeBytes)
assertTrue(snap.raw.single { it.name == "note.txt" }.content.contains("hello"))
}
@Test
fun `force layout is deterministic and bounded`() {
val edges = listOf(0 to 1, 1 to 2, 2 to 0, 2 to 3)
val first = MemoryStore.forceLayout(4, edges)
val second = MemoryStore.forceLayout(4, edges)
assertEquals(4, first.size)
assertEquals(first, second)
first.forEach { p ->
assertTrue(p.x in -500f..500f)
assertTrue(p.y in -350f..350f)
}
}
@Test
fun `force layout pulls linked nodes closer than unlinked ones`() {
val chain = MemoryStore.forceLayout(5, listOf(0 to 1, 1 to 2, 2 to 3, 3 to 4), iterations = 300)
fun dist(a: Int, b: Int): Float = (chain[a] - chain[b]).getDistance()
val linked = listOf(dist(0, 1), dist(1, 2), dist(2, 3), dist(3, 4)).average()
val unlinked = listOf(dist(0, 2), dist(0, 3), dist(0, 4), dist(1, 3), dist(1, 4), dist(2, 4)).average()
assertTrue("linked=$linked unlinked=$unlinked", linked < unlinked)
}
@Test
fun `force layout handles empty and single node`() {
assertTrue(MemoryStore.forceLayout(0, emptyList()).isEmpty())
assertEquals(1, MemoryStore.forceLayout(1, emptyList()).size)
}
@Test
fun `confinement keeps every point inside the brain`() {
val points = listOf(
androidx.compose.ui.geometry.Offset(900f, 700f),
androidx.compose.ui.geometry.Offset(-50f, 20f),
androidx.compose.ui.geometry.Offset(0f, 0f)
)
val depths = listOf(500f, 10f, 0f)
val (keptPoints, keptDepths) = MemoryStore.confineToBrain(points, depths)
assertEquals(3, keptPoints.size)
keptPoints.zip(keptDepths).forEach { (p, z) ->
val e = (p.x / MemoryStore.BRAIN_RX).let { it * it } +
(p.y / MemoryStore.BRAIN_RY).let { it * it } +
(z / MemoryStore.BRAIN_RZ).let { it * it }
assertTrue("e=$e", e <= 0.81f + 1e-3f)
}
// Inside points pass through untouched.
assertEquals(points[1], keptPoints[1])
assertEquals(points[2], keptPoints[2])
}
// ---- Second Brain Phase 1: record schema, digest, history, timezone ----
private fun goodRecord(): String = listOf(
"---",
"title: Trip Plan",
"area: Personal",
"type: note",
"tags: [travel, japan-2026]",
"updated: 2026-10-29",
"source: user chat",
"source_file: raw/memo.mp3",
"---",
"",
"# Trip Plan",
"",
"See [[areas/personal.md]].",
""
).joinToString("\n")
@Test
fun `seeded area hubs carry valid frontmatter`() {
MemoryStore.ensureDefaults(Settings())
GotchaStorage.memoryAreasDir().listFiles()!!.forEach { hub ->
val check = MemoryStore.validateRecord(hub.name, hub.readText())
assertTrue("${hub.name}: ${check.errors}", check.valid)
}
}
@Test
fun `validateRecord accepts a complete record`() {
MemoryStore.ensureDefaults(Settings())
val check = MemoryStore.validateRecord("trip.md", goodRecord())
assertTrue(check.errors.toString(), check.valid)
}
@Test
fun `validateRecord rejects missing frontmatter`() {
MemoryStore.ensureDefaults(Settings())
val check = MemoryStore.validateRecord("trip.md", "# No frontmatter\n\nBody.\n")
assertFalse(check.valid)
assertTrue(check.errors.any { it.contains("frontmatter") })
}
@Test
fun `validateRecord rejects bad fields`() {
MemoryStore.ensureDefaults(Settings())
val bad = listOf(
"---",
"title: ",
"area: Atlantis",
"type: nonsense",
"tags: [Bad Tag, ok]",
"updated: 29-10-2026",
"mystery: 1",
"---",
"",
"Body.",
""
).joinToString("\n")
val check = MemoryStore.validateRecord("bad.md", bad)
assertFalse(check.valid)
val joined = check.errors.joinToString("\n")
assertTrue(joined, joined.contains("'title'"))
assertTrue(joined, joined.contains("Atlantis"))
assertTrue(joined, joined.contains("nonsense"))
assertTrue(joined, joined.contains("Bad Tag"))
assertTrue(joined, joined.contains("updated"))
assertTrue(joined, joined.contains("mystery"))
}
@Test
fun `validateRecord rejects empty bodies`() {
MemoryStore.ensureDefaults(Settings())
val check = MemoryStore.validateRecord(
"empty.md",
"---\ntitle: T\narea: Work\ntype: note\nupdated: 2026-10-29\n---\n"
)
assertFalse(check.valid)
assertTrue(check.errors.any { it.contains("empty body") })
}
@Test
fun `parseTags handles inline lists and single slugs`() {
assertEquals(listOf("travel", "japan-2026"), MemoryStore.parseTags("[travel, japan-2026]"))
assertEquals(emptyList<String>(), MemoryStore.parseTags("[]"))
assertEquals(listOf("solo"), MemoryStore.parseTags("solo"))
}
@Test
fun `isKnownArea accepts starter and custom hubs`() {
MemoryStore.ensureDefaults(Settings())
assertTrue(MemoryStore.isKnownArea("Work"))
assertTrue(MemoryStore.isKnownArea("work"))
File(GotchaStorage.memoryAreasDir(), "sidequest.md").writeText("# Sidequest\n")
assertTrue(MemoryStore.isKnownArea("sidequest"))
assertFalse(MemoryStore.isKnownArea("Atlantis"))
}
@Test
fun `isDetailRecord gates only detail markdown`() {
MemoryStore.ensureDefaults(Settings())
assertTrue(MemoryStore.isDetailRecord(File(GotchaStorage.memoryNotesDir(), "trip.md")))
assertTrue(MemoryStore.isDetailRecord(File(GotchaStorage.memoryPeopleDir(), "asha.markdown")))
assertFalse(MemoryStore.isDetailRecord(GotchaStorage.soulFile()))
assertFalse(MemoryStore.isDetailRecord(GotchaStorage.memoryIndexFile()))
assertFalse(MemoryStore.isDetailRecord(GotchaStorage.memoryUserFile()))
assertFalse(MemoryStore.isDetailRecord(File(GotchaStorage.memoryRawDir(), "memo.mp3")))
assertFalse(MemoryStore.isDetailRecord(File(GotchaStorage.memoryNotesDir(), "clip.mp3")))
}
@Test
fun `listStaleRaw flags files older than 30 days`() {
MemoryStore.ensureDefaults(Settings())
val rawDir = GotchaStorage.memoryRawDir().apply { mkdirs() }
val old = File(rawDir, "old-memo.mp3").apply {
writeBytes(byteArrayOf(1, 2, 3))
setLastModified(System.currentTimeMillis() - 40L * 24 * 60 * 60 * 1000)
}
val fresh = File(rawDir, "fresh.txt").apply { writeText("new") }
val stale = MemoryStore.listStaleRaw()
assertTrue(stale.map { it.name }.contains(old.name))
assertFalse(stale.map { it.name }.contains(fresh.name))
}
@Test
fun `isEphemeralPath spots staging paths`() {
assertTrue(MemoryStore.isEphemeralPath("/tmp/voice.mp3"))
assertTrue(MemoryStore.isEphemeralPath("/data/cache/memo.pdf"))
assertTrue(MemoryStore.isEphemeralPath("/sdcard/Temp/clip.mp4"))
assertTrue(MemoryStore.isEphemeralPath("/sdcard/Download/draft.tmp"))
assertFalse(MemoryStore.isEphemeralPath("/sdcard/Documents/paper.pdf"))
}
@Test
fun `isDatedNote detects dated names`() {
assertTrue(MemoryStore.isDatedNote("2026-10-29-sync.md"))
assertFalse(MemoryStore.isDatedNote("trip.md"))
assertFalse(MemoryStore.isDatedNote("2026-13-99-bogus.md"))
}
@Test
fun `memory dates use the device timezone`() {
assertTrue(MemoryStore.deviceTimezoneId().isNotBlank())
val expected = java.time.LocalDate.ofInstant(
java.time.Instant.ofEpochMilli(0),
java.time.ZoneId.systemDefault()
).toString()
assertEquals(expected, MemoryStore.formatDateForMemory(0))
assertTrue(MemoryStore.formatDateForMemory().matches(Regex("\\d{4}-\\d{2}-\\d{2}")))
}
// ---- Codex review follow-ups ----
private fun record(type: String, area: String, tags: String = "[x]"): String = listOf(
"---",
"title: T",
"area: $area",
"type: $type",
"tags: $tags",
"updated: 2026-10-29",
"---",
"",
"Body.",
""
).joinToString("\n")
@Test
fun `validateRecord treats quoted empty values as blank`() {
MemoryStore.ensureDefaults(Settings())
val check = MemoryStore.validateRecord(
"q.md",
"---\ntitle: \"\"\narea: Work\ntype: note\nupdated: 2026-10-29\n---\n\nBody.\n"
)
assertFalse(check.valid)
assertTrue(check.errors.any { it.contains("'title'") })
}
@Test
fun `validateRecord rejects commas inside quoted tags`() {
MemoryStore.ensureDefaults(Settings())
val check = MemoryStore.validateRecord("t.md", record("note", "Work", "[\"bad,tag\"]"))
assertFalse(check.valid)
assertTrue(check.errors.any { it.contains("bad,tag") })
}
@Test
fun `validateRecord accepts block scalars`() {
MemoryStore.ensureDefaults(Settings())
val body = listOf(
"---",
"title: T",
"area: Work",
"type: note",
"updated: 2026-10-29",
"summary: |",
" first line without a colon",
" second: still part of the value",
"---",
"",
"Body.",
""
).joinToString("\n")
val check = MemoryStore.validateRecord("b.md", body)
assertTrue(check.errors.toString(), check.valid)
}
@Test
fun `validateRecord enforces type per directory`() {
MemoryStore.ensureDefaults(Settings())
val misplaced = MemoryStore.validateRecord("work.md", record("note", "Work"), "areas")
assertFalse(misplaced.valid)
assertTrue(misplaced.errors.any { it.contains("areas/") })
assertTrue(MemoryStore.validateRecord("work.md", record("area", "Work"), "areas").valid)
assertTrue(MemoryStore.validateRecord("asha.md", record("person", "People"), "people").valid)
assertTrue(MemoryStore.validateRecord("sync.md", record("decision", "Work"), "notes").valid)
// Without directory context the type check stays lenient.
assertTrue(MemoryStore.validateRecord("work.md", record("note", "Work")).valid)
}
@Test
fun `area bootstrap accepts the new hub name`() {
MemoryStore.ensureDefaults(Settings())
assertFalse(MemoryStore.isKnownArea("Research"))
val check = MemoryStore.validateRecord("Research.md", record("area", "Research"), "areas")
assertTrue(check.errors.toString(), check.valid)
}
@Test
fun `ensureDefaults migrates legacy hubs`() {
MemoryStore.ensureDefaults(Settings())
val hub = File(GotchaStorage.memoryAreasDir(), "work.md")
hub.writeText("# Work\n\nLegacy plain markdown.\n")
MemoryStore.ensureDefaults(Settings())
val text = hub.readText()
assertTrue(text.lines().first() == "---")
assertTrue(text.contains("Legacy plain markdown."))
val check = MemoryStore.validateRecord(hub.name, text, "areas")
assertTrue(check.errors.toString(), check.valid)
}
// ---- Phase 2: task links, duplicates, health ----
@Test
fun `validateRecord accepts task link fields`() {
MemoryStore.ensureDefaults(Settings())
val rec = listOf(
"---",
"title: Trip",
"area: Personal",
"type: note",
"tags: [travel]",
"updated: 2026-10-29",
"next_action: Book flights",
"task_ref: 123e4567-e89b-12d3-a456-426614174000",
"---",
"",
"Body.",
""
).joinToString("\n")
val check = MemoryStore.validateRecord("trip.md", rec, "notes")
assertTrue(check.errors.toString(), check.valid)
}
@Test
fun `validateRecord rejects blank task link fields`() {
MemoryStore.ensureDefaults(Settings())
val rec = record("note", "Personal").replace("tags: [x]", "tags: [x]\ntask_ref: ")
val check = MemoryStore.validateRecord("trip.md", rec, "notes")
assertFalse(check.valid)
assertTrue(check.errors.any { it.contains("task_ref") })
}
@Test
fun `checkHealth reports orphans`() {
MemoryStore.ensureDefaults(Settings())
val notes = GotchaStorage.memoryNotesDir().apply { mkdirs() }
fun note(name: String, body: String, extra: String = "") {
File(notes, name).writeText(
listOf(
"---",
"title: $name",
"area: Personal",
"type: note",
"updated: 2026-10-29",
extra,
"---",
"",
body,
""
).filter { it.isNotEmpty() }.joinToString("\n")
)
}
note("a.md", "See [[notes/b.md]].")
note("b.md", "See [[notes/a.md]].")
note("c.md", "Lonely.")
note("d.md", "See [[nowhere-at-all]].")
File(notes, "e.md").writeText("No frontmatter.\n")
note("f.md", "Waiting on a task.", "task_ref: dead-beef")
val snap = MemoryStore.loadSnapshot()
val health = MemoryStore.checkHealth(snap)
assertTrue(health.unlinked.contains("notes/c.md"))
assertTrue(health.unlinked.contains("notes/d.md"))
assertTrue(health.unlinked.contains("notes/e.md"))
assertTrue(health.unlinked.contains("notes/f.md"))
assertFalse(health.unlinked.contains("notes/a.md"))
assertFalse(health.unlinked.contains("notes/b.md"))
assertFalse(health.unlinked.contains("SOUL.md"))
assertFalse(health.unlinked.contains("MEMORY.md"))
assertFalse(health.unlinked.contains("user.md"))
assertEquals(
listOf(MemoryStore.DanglingLink("notes/d.md", "nowhere-at-all")),
health.dangling
)
assertEquals(listOf("notes/e.md"), health.invalid.map { it.fileId })
assertEquals(
listOf(MemoryStore.TaskNoteRef("notes/f.md", "dead-beef")),
health.unknownTasks
)
assertFalse(health.isClean)
val linked = MemoryStore.checkHealth(
snap,
listOf(MemoryStore.TaskLink("dead-beef", "Task", File(notes, "f.md").absolutePath))
)
assertTrue(linked.unknownTasks.isEmpty())
assertTrue(linked.mismatchedTasks.isEmpty())
assertTrue(linked.staleTaskLinks.isEmpty())
}
@Test
fun `checkHealth flags mismatched and stale task links`() {
MemoryStore.ensureDefaults(Settings())
val notes = GotchaStorage.memoryNotesDir().apply { mkdirs() }
File(notes, "g.md").writeText(
listOf(
"---",
"title: G",
"area: Personal",
"type: note",
"updated: 2026-10-29",
"task_ref: real-id",
"---",
"",
"Body.",
""
).joinToString("\n")
)
File(notes, "h.md").writeText(
listOf(
"---",
"title: H",
"area: Personal",
"type: note",
"updated: 2026-10-29",
"task_ref: lonely-id",
"---",
"",
"Body.",
""
).joinToString("\n")
)
File(notes, "i.md").writeText(record("note", "Personal").replace("title: T", "title: I"))
val snap = MemoryStore.loadSnapshot()
val gPath = File(notes, "g.md").absolutePath
val iPath = File(notes, "i.md").absolutePath
val health = MemoryStore.checkHealth(
snap,
listOf(
MemoryStore.TaskLink("real-id", "Task", "/other/note.md"),
MemoryStore.TaskLink("lonely-id", "Lonely", null),
MemoryStore.TaskLink("boss-id", "Boss", gPath),
MemoryStore.TaskLink("aim-id", "Aim", iPath)
)
)
assertTrue(health.unknownTasks.isEmpty())
assertTrue(
health.mismatchedTasks.contains(
MemoryStore.TaskMismatch("notes/g.md", "real-id", "/other/note.md")
)
)
assertTrue(
health.mismatchedTasks.contains(
MemoryStore.TaskMismatch("notes/h.md", "lonely-id", null)
)
)
assertTrue(
health.missingBacklinks.contains(
MemoryStore.MissingBacklink("notes/g.md", "Boss")
)
)
assertTrue(
health.missingBacklinks.contains(
MemoryStore.MissingBacklink("notes/i.md", "Aim")
)
)
assertEquals(
listOf(MemoryStore.StaleTaskLink("Task", "/other/note.md")),
health.staleTaskLinks
)
assertFalse(health.isClean)
}
@Test
fun `checkHealth flags files past the link scan cap`() {
MemoryStore.ensureDefaults(Settings())
val notes = GotchaStorage.memoryNotesDir().apply { mkdirs() }
val filler = "x".repeat(MemoryStore.LINK_SCAN_CAP_CHARS)
File(notes, "big.md").writeText(
record("note", "Personal").replace("Body.", "See [[areas/work.md]].\n\n$filler")
)
val snap = MemoryStore.loadSnapshot()
val health = MemoryStore.checkHealth(snap)
assertTrue(health.unscanned.contains("notes/big.md"))
// The link at the start still resolves, so no false unlinked/dangling.
assertFalse(health.unlinked.contains("notes/big.md"))
assertTrue(health.dangling.none { it.fromId == "notes/big.md" })
}
@Test
fun `ambiguous bare names are not dangling`() {
MemoryStore.ensureDefaults(Settings())
val notes = GotchaStorage.memoryNotesDir().apply { mkdirs() }
val people = GotchaStorage.memoryPeopleDir().apply { mkdirs() }
File(notes, "plan.md").writeText(record("note", "Personal"))
File(people, "plan.md").writeText(record("person", "People"))
File(GotchaStorage.memoryAreasDir(), "hub.md").writeText(
record("area", "Work").replace("Body.", "See [[plan]].")
)
val snap = MemoryStore.loadSnapshot()
assertTrue(MemoryStore.findDanglingLinks(snap).none { it.target == "plan" })
}
@Test
fun `wiki links ignore fenced code blocks`() {
assertEquals(
listOf("notes/real.md"),
MemoryStore.parseWikiLinks("```\nSee [[notes/fake.md]].\n```\nSee [[notes/real.md]].")
)
assertEquals(
listOf("notes/real.md"),
MemoryStore.parseWikiLinks("~~~\nSee [[notes/fake.md]].\n~~~\nSee [[notes/real.md]].")
)
assertEquals(
listOf("notes/real.md"),
MemoryStore.parseWikiLinks("See [[notes/real.md]].\n```\nUnclosed [[notes/fake.md]].")
)
}
@Test
fun `detail listing includes markdown files`() {
MemoryStore.ensureDefaults(Settings())
File(GotchaStorage.memoryAreasDir(), "extra.markdown").writeText(
record("area", "Work").replace("title: T", "title: Extra")
)
val snap = MemoryStore.loadSnapshot()
assertTrue(snap.areas.map { it.name }.contains("extra.markdown"))
}
@Test
fun `findPossibleDuplicates keeps dots in titles`() {
MemoryStore.ensureDefaults(Settings())
val notes = GotchaStorage.memoryNotesDir().apply { mkdirs() }
File(notes, "release-2-0.md").writeText(record("note", "Work"))
File(notes, "release-2.md").writeText(record("note", "Work"))
val snap = MemoryStore.loadSnapshot()
assertEquals(
listOf("notes/release-2-0.md"),
MemoryStore.findPossibleDuplicates("Release 2.0", snap)
)
}
@Test
fun `slugify normalizes names`() {
assertEquals("asha-sharma", MemoryStore.slugify("Asha Sharma"))
assertEquals("k99", MemoryStore.slugify("K99"))
assertEquals("3d-kinematics", MemoryStore.slugify("3D Kinematics!"))
assertEquals("", MemoryStore.slugify("---"))
}
@Test
fun `findPossibleDuplicates catches renames`() {
MemoryStore.ensureDefaults(Settings())
val people = GotchaStorage.memoryPeopleDir().apply { mkdirs() }
File(people, "asha-sharma.md").writeText(
record("person", "People").replace("title: T", "title: Asha Sharma")
)
val snap = MemoryStore.loadSnapshot()
assertTrue(
MemoryStore.findPossibleDuplicates("Asha Sharma", snap).contains("people/asha-sharma.md")
)
assertTrue(
MemoryStore.findPossibleDuplicates("asha-sharma", snap).contains("people/asha-sharma.md")
)
assertTrue(MemoryStore.findPossibleDuplicates("Nobody Here", snap).isEmpty())
}
// ---- Phase 3: viewer search ----
@Test
fun `filterSnapshot with a blank query returns everything`() {
MemoryStore.ensureDefaults(Settings())
val snap = MemoryStore.loadSnapshot()
val filtered = MemoryStore.filterSnapshot(snap, " ")
assertEquals(snap.areas.size, filtered.areas.size)
assertEquals(snap.notes.size, filtered.notes.size)
assertNotNull(filtered.soul)
}
@Test
fun `filterSnapshot matches names and contents`() {
MemoryStore.ensureDefaults(Settings())
val notes = GotchaStorage.memoryNotesDir().apply { mkdirs() }
File(notes, "trip.md").writeText(record("note", "Personal").replace("Body.", "Kyoto itinerary."))
File(notes, "other.md").writeText(record("note", "Personal").replace("Body.", "Unrelated."))
val rawDir = GotchaStorage.memoryRawDir().apply { mkdirs() }
File(rawDir, "receipt.txt").writeText("Kyoto taxi")
val snap = MemoryStore.loadSnapshot()
val byName = MemoryStore.filterSnapshot(snap, "trip")
assertEquals(listOf("trip.md"), byName.notes.map { it.name })
val byContent = MemoryStore.filterSnapshot(snap, "kyoto")
assertEquals(listOf("trip.md"), byContent.notes.map { it.name })
assertEquals(listOf("receipt.txt"), byContent.raw.map { it.name })
val none = MemoryStore.filterSnapshot(snap, "zzzz-no-match")
assertTrue(none.notes.isEmpty())
assertNull(none.soul)
}
@Test
fun `filterSnapshot searches past the preview cap`() {
MemoryStore.ensureDefaults(Settings())
val notes = GotchaStorage.memoryNotesDir().apply { mkdirs() }
val filler = "x".repeat(MemoryStore.VIEWER_FILE_CAP_CHARS)
File(notes, "long.md").writeText(
record("note", "Personal").replace("Body.", "$filler needle-term")
)
val snap = MemoryStore.loadSnapshot()
assertTrue(snap.notes.single { it.name == "long.md" }.truncated)
val found = MemoryStore.filterSnapshot(snap, "needle-term")
assertEquals(listOf("long.md"), found.notes.map { it.name })
}
}