@rekal/mem 0.0.0

package/test/query.test.ts

@@ -0,0 +1,105 @@
+// oxlint-disable sort-keys
+import { describe, expect, test } from "vitest"
+import { toFts, tokenize } from "../src/query.ts"
+
+describe("tokenize", () => {
+  const cases: Record<string, ReturnType<typeof tokenize>> = {
+    "children family": [
+      { type: "term", value: "children" },
+      { type: "term", value: "family" },
+    ],
+    '"my children"': [{ type: "term", value: "my children" }],
+    "'my children'": [{ type: "term", value: "my children" }],
+    "-sports": [{ type: "term", value: "sports", neg: true }],
+    "children | kids": [
+      { type: "term", value: "children" },
+      { type: "op", value: "OR" },
+      { type: "term", value: "kids" },
+    ],
+    "(children | kids) family": [
+      { type: "paren", value: "(" },
+      { type: "term", value: "children" },
+      { type: "op", value: "OR" },
+      { type: "term", value: "kids" },
+      { type: "paren", value: ")" },
+      { type: "term", value: "family" },
+    ],
+    '"my children': [{ type: "term", value: "my children" }],
+    '""': [],
+    "what's up": [
+      { type: "term", value: "what's" },
+      { type: "term", value: "up" },
+    ],
+    "child*": [{ type: "term", value: "child*" }],
+    "entities:Lars": [{ type: "term", value: "Lars", field: "entities" }],
+    "tags:family children": [
+      { type: "term", value: "family", field: "tags" },
+      { type: "term", value: "children" },
+    ],
+    "-tags:sports": [{ type: "term", value: "sports", field: "tags", neg: true }],
+    "+children": [{ type: "term", value: "children", req: true }],
+    "+tags:family": [{ type: "term", value: "family", field: "tags", req: true }],
+    "unknown:foo": [{ type: "term", value: "unknown:foo" }],
+    'children -sports "my family" | (kids age)': [
+      { type: "term", value: "children" },
+      { type: "term", value: "sports", neg: true },
+      { type: "term", value: "my family" },
+      { type: "op", value: "OR" },
+      { type: "paren", value: "(" },
+      { type: "term", value: "kids" },
+      { type: "term", value: "age" },
+      { type: "paren", value: ")" },
+    ],
+  }
+
+  for (const [input, expected] of Object.entries(cases)) {
+    test(input, () => expect(tokenize(input)).toEqual(expected))
+  }
+})
+
+describe("toFts", () => {
+  const or: Record<string, string> = {
+    "children family": '"children" OR "family"',
+    "children | kids": '"children" OR "kids"',
+    "children -sports": '"children" OR NOT "sports"',
+    '"my children"': '"my children"',
+    "'my children'": '"my children"',
+    "(children | kids) family": '("children" OR "kids") OR "family"',
+    "what's children?": '"what\'s" OR "children"',
+    "": "",
+    kids: '"kids"',
+    "child*": '"child"*',
+    "child* family": '"child"* OR "family"',
+    "child* famil*": '"child"* OR "famil"*',
+    "-sport*": 'NOT "sport"*',
+    "entities:Lars": 'entities : "Lars"',
+    "tags:family children": 'tags : "family" OR "children"',
+    "-tags:sports": 'NOT tags : "sports"',
+    "entities:Lars tags:family": 'entities : "Lars" OR tags : "family"',
+    "entities:Lars* tags:fam*": 'entities : "Lars"* OR tags : "fam"*',
+    "unknown:foo": '"unknown:foo"',
+    "folke +children": '"children" AND ("folke" OR "children")',
+    "+children folke": '"children" AND ("children" OR "folke")',
+    "folke +children +family": '"children" AND "family" AND ("folke" OR "children" OR "family")',
+    "+tags:family children": 'tags : "family" AND (tags : "family" OR "children")',
+    "+children": '"children"',
+  }
+
+  const and: Record<string, string> = {
+    "children family": '"children" AND "family"',
+    "children | kids": '"children" OR "kids"',
+    "children -sports": '"children" AND NOT "sports"',
+    "(children | kids) family": '("children" OR "kids") AND "family"',
+    "(children kids) family": '("children" AND "kids") AND "family"',
+    "child* family": '"child"* AND "family"',
+    "what's my name?": '"what\'s" AND "my" AND "name"',
+  }
+
+  for (const [input, expected] of Object.entries(or)) {
+    test(`OR: ${input}`, () => expect(toFts(input)).toBe(expected))
+  }
+
+  for (const [input, expected] of Object.entries(and)) {
+    test(`AND: ${input}`, () => expect(toFts(input, "AND")).toBe(expected))
+  }
+})

package/test/uri.test.ts

@@ -0,0 +1,46 @@
+// oxlint-disable sort-keys
+import { describe, expect, test } from "vitest"
+import { normUri, parentUri } from "../src/uri.ts"
+
+describe("normUri", () => {
+  const cases: { input?: string; dir?: boolean; expected: string }[] = [
+    { expected: "rekal://" },
+    { input: "", expected: "rekal://" },
+    { input: " ", expected: "rekal://" },
+    { input: "foo", expected: "rekal://foo" },
+    { input: "foo/bar", expected: "rekal://foo/bar" },
+    { input: "foo/bar/index.md", expected: "rekal://foo/bar/" },
+    { input: "rekal://notes", expected: "rekal://notes" },
+    { input: "rekal://notes/", expected: "rekal://notes/" },
+    { input: "rekall://test", expected: "rekal://test" },
+    { input: "a//b///c", expected: "rekal://a/b/c" },
+    { input: "///a/b", expected: "rekal://a/b" },
+    { input: "a\\b\\c", expected: "rekal://a/b/c" },
+    { input: "foo", dir: true, expected: "rekal://foo/" },
+    { input: "foo/bar", dir: true, expected: "rekal://foo/bar/" },
+    { input: "foo/bar/", dir: true, expected: "rekal://foo/bar/" },
+    { input: "foo", dir: false, expected: "rekal://foo" },
+    { input: "foo/bar/", dir: false, expected: "rekal://foo/bar" },
+  ]
+
+  for (const { input, dir, expected } of cases) {
+    test(`normUri(${JSON.stringify(input)}, ${dir}) => ${expected}`, () =>
+      expect(normUri(input, dir)).toBe(expected))
+  }
+})
+
+describe("parentUri", () => {
+  const cases: { input: string; expected: string | undefined }[] = [
+    { input: "rekal://", expected: undefined },
+    { input: "rekal://foo", expected: "rekal://" },
+    { input: "rekal://foo/", expected: "rekal://" },
+    { input: "rekal://foo\\bar", expected: "rekal://foo/" },
+    { input: "rekal://foo/bar/", expected: "rekal://foo/" },
+    { input: "rekal://foo/bar/baz.md", expected: "rekal://foo/bar/" },
+    { input: "rekal://a/b/c/d", expected: "rekal://a/b/c/" },
+  ]
+
+  for (const { input, expected } of cases) {
+    test(`parentUri(${input}) => ${expected}`, () => expect(parentUri(input)).toBe(expected))
+  }
+})

package/test/util.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "vitest"
+import { parseFrontmatter } from "../src/md.ts"
+
+describe("parseFrontmatter", () => {
+  test("parses yaml frontmatter", () => {
+    const { frontmatter, body } = parseFrontmatter(`---
+summary: "hello world"
+tags: [a, b]
+---
+
+# Title
+
+Body text.
+`)
+    expect(frontmatter).toEqual({ summary: "hello world", tags: ["a", "b"] })
+    expect(body).toContain("# Title")
+    expect(body).toContain("Body text.")
+  })
+
+  test("returns empty data when no frontmatter", () => {
+    const { frontmatter, body } = parseFrontmatter("Just plain text.")
+    expect(frontmatter).toEqual({})
+    expect(body).toBe("Just plain text.")
+  })
+
+  test("handles missing closing delimiter gracefully", () => {
+    const { frontmatter, body } = parseFrontmatter(`---
+summary: "oops"
+No closing delimiter here.
+`)
+    // Should not crash — returns empty frontmatter, full content as body
+    expect(frontmatter).toEqual({})
+    expect(body).toContain("summary")
+  })
+
+  test("handles empty frontmatter", () => {
+    const { frontmatter, body } = parseFrontmatter(`---
+---
+
+Content after empty frontmatter.
+`)
+    expect(frontmatter).toEqual({})
+    expect(body).toContain("Content after empty frontmatter.")
+  })
+
+  test("handles complex yaml values", () => {
+    const { frontmatter } = parseFrontmatter(`---
+entities: [Folke, "Lars Lemaitre", snacks.nvim]
+tags:
+  - user
+  - family
+nested:
+  key: value
+---
+
+Body.
+`)
+    expect(frontmatter.entities).toEqual(["Folke", "Lars Lemaitre", "snacks.nvim"])
+    expect(frontmatter.tags).toEqual(["user", "family"])
+    expect(frontmatter.nested).toEqual({ key: "value" })
+  })
+})

package/test/vfs.test.ts

@@ -0,0 +1,164 @@
+import type { VfsEntry } from "../src/vfs.ts"
+
+import { fileURLToPath } from "node:url"
+import { join } from "pathe"
+import { describe, expect, test } from "vitest"
+import { Context } from "../src/context.ts"
+import { Vfs } from "../src/vfs.ts"
+
+const FIXTURES = join(fileURLToPath(import.meta.url), "..", "fixtures/store")
+
+function createVfs() {
+  const ctx = new Context({})
+  return new Vfs(ctx)
+}
+
+async function collect(vfs: Vfs, uri: string, depth?: number) {
+  const results: VfsEntry[] = []
+  for await (const item of vfs.find({ depth, uri })) {
+    results.push(item)
+  }
+  return results
+}
+
+describe("Vfs addFolder", () => {
+  test("adds a folder to the VFS", () => {
+    const vfs = createVfs()
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://notes" })
+    expect(vfs.folders).toHaveLength(1)
+    expect(vfs.folders[0].uri).toBe("rekal://notes/")
+  })
+
+  test("normalizes trailing slash on URI", () => {
+    const vfs = createVfs()
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://notes" })
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://docs/" })
+    expect(vfs.folders[0].uri).toBe("rekal://notes/")
+    expect(vfs.folders[1].uri).toBe("rekal://docs/")
+  })
+})
+
+describe("Vfs find", () => {
+  test("finds files in a single mount", async () => {
+    const vfs = createVfs()
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://store" })
+    const results = await collect(vfs, "rekal://store")
+    expect(results.length).toBeGreaterThan(0)
+
+    const uris = results.map((r) => r.uri)
+    expect(uris.some((u) => u.includes("family.md"))).toBe(true)
+    expect(uris.some((u) => u.includes("user/"))).toBe(true)
+  })
+
+  test("depth=1 shows only immediate children", async () => {
+    const vfs = createVfs()
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://store" })
+    const results = await collect(vfs, "rekal://store", 1)
+    const uris = results.map((r) => r.uri)
+
+    // Should see top-level dirs (index.md is filtered as a dir node)
+    expect(uris.some((u) => u === "rekal://store/user/")).toBe(true)
+    expect(uris.some((u) => u === "rekal://store/projects/")).toBe(true)
+
+    // Should NOT see nested files
+    expect(uris.some((u) => u.includes("family.md"))).toBe(false)
+  })
+
+  test("nested mount appears as virtual directory", async () => {
+    const vfs = createVfs()
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://notes" })
+    vfs.addFolder({ path: join(FIXTURES, "concepts"), uri: "rekal://notes/extra" })
+    const results = await collect(vfs, "rekal://notes", 1)
+    const uris = results.map((r) => r.uri)
+
+    // The nested mount should appear as a directory
+    expect(uris).toContain("rekal://notes/extra/")
+  })
+
+  test("nested mount has correct path", async () => {
+    const vfs = createVfs()
+    const toolsDir = join(FIXTURES, "concepts")
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://notes" })
+    vfs.addFolder({ path: toolsDir, uri: "rekal://notes/extra" })
+    const results = await collect(vfs, "rekal://notes", 1)
+
+    const extra = results.find((r) => r.uri === "rekal://notes/extra/")
+    expect(extra).toBeDefined()
+    // Should have a path from the explicit mount
+    expect(extra!.path.startsWith(toolsDir)).toBe(true)
+  })
+
+  test("nested mount contents are found at depth=2", async () => {
+    const vfs = createVfs()
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://notes" })
+    vfs.addFolder({ path: join(FIXTURES, "concepts"), uri: "rekal://notes/extra" })
+    const results = await collect(vfs, "rekal://notes", 2)
+    const uris = results.map((r) => r.uri)
+
+    // Should find files inside the nested mount
+    expect(uris.some((u) => u.includes("extra/") && u.endsWith(".md"))).toBe(true)
+  })
+
+  test("find below a mount resolves correctly", async () => {
+    const vfs = createVfs()
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://store" })
+    const results = await collect(vfs, "rekal://store/user")
+    const uris = results.map((r) => r.uri)
+
+    expect(uris.some((u) => u.includes("family.md"))).toBe(true)
+    expect(uris.some((u) => u.includes("preferences.md"))).toBe(true)
+    // Should NOT include files from other top-level dirs
+    expect(uris.some((u) => u.includes("concepts/"))).toBe(false)
+  })
+
+  test("multiple paths for same URI prefix", async () => {
+    const vfs = createVfs()
+    vfs.addFolder({ path: join(FIXTURES, "user"), uri: "rekal://merged" })
+    vfs.addFolder({ path: join(FIXTURES, "concepts"), uri: "rekal://merged" })
+    const results = await collect(vfs, "rekal://merged")
+    const uris = results.map((r) => r.uri)
+
+    // Should find files from both directories
+    expect(uris.some((u) => u.includes("family.md"))).toBe(true) // from user
+    expect(uris.some((u) => u.includes("frecency.md"))).toBe(true) // from concepts
+  })
+
+  test("deduplicates URIs from overlapping mounts", async () => {
+    const vfs = createVfs()
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://notes" })
+    // Mount the user subdir again explicitly
+    vfs.addFolder({ path: join(FIXTURES, "user"), uri: "rekal://notes/user" })
+    const results = await collect(vfs, "rekal://notes")
+    const uris = results.map((r) => r.uri)
+
+    // family.md should appear only once
+    const familyResults = uris.filter((u) => u === "rekal://notes/user/family.md")
+    expect(familyResults).toHaveLength(1)
+  })
+
+  test("overlapping mount yields results from both sources", async () => {
+    const vfs = createVfs()
+    const userDir = join(FIXTURES, "user")
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://notes" })
+    vfs.addFolder({ path: userDir, uri: "rekal://notes/user" })
+    const results = await collect(vfs, "rekal://notes")
+    const uris = results.map((r) => r.uri)
+
+    // Should find the user/ directory and files from both mounts
+    expect(uris.some((u) => u === "rekal://notes/user/")).toBe(true)
+    expect(uris.some((u) => u.includes("family.md"))).toBe(true)
+  })
+})
+
+describe("Vfs ls", () => {
+  test("ls is equivalent to find with depth=1", async () => {
+    const vfs = createVfs()
+    vfs.addFolder({ path: FIXTURES, uri: "rekal://store" })
+    const lsResults = await collect(vfs, "rekal://store", 1)
+    const findResults: VfsEntry[] = []
+    for await (const item of vfs.ls({ uri: "rekal://store" })) {
+      findResults.push(item)
+    }
+    expect(lsResults.map((r) => r.uri).toSorted()).toEqual(findResults.map((r) => r.uri).toSorted())
+  })
+})

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/tsdown.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsdown"
+
+export default defineConfig({
+  entry: {
+    glob: "src/glob.ts",
+    index: "src/index.ts",
+  },
+})