@rekal/mem 0.0.0 → 0.0.2

package/test/glob.test.ts

@@ -1,190 +0,0 @@
-import { fileURLToPath } from "node:url"
-import { join } from "pathe"
-import { describe, expect, test } from "vitest"
-import { glob } from "../src/glob.ts"
-
-const FIXTURES = join(fileURLToPath(import.meta.url), "..", "fixtures/store")
-
-async function collect(opts: Partial<Parameters<typeof glob>[0]> = {}) {
-  const results: string[] = []
-  for await (const path of glob({ cwd: FIXTURES, ...opts })) {
-    results.push(path)
-  }
-  return results
-}
-
-describe("glob", () => {
-  test("yields files and directories", async () => {
-    const results = await collect()
-    expect(results.length).toBeGreaterThan(0)
-    expect(results.some((r) => r.endsWith(".md"))).toBe(true)
-    expect(results.some((r) => r.endsWith("/"))).toBe(true)
-  })
-
-  test("finds known fixture files", async () => {
-    const results = await collect()
-    expect(results).toContain("index.md")
-    expect(results).toContain("user/")
-    expect(results).toContain("user/family.md")
-    expect(results).toContain("user/index.md")
-    expect(results).toContain("projects/rekall-inc/decisions/no-military.md")
-  })
-
-  test("results are sorted by name", async () => {
-    const results = await collect()
-    const topLevelFiles = results.filter((r) => !r.includes("/") && r.endsWith(".md"))
-    const sorted = [...topLevelFiles].toSorted()
-    expect(topLevelFiles).toEqual(sorted)
-  })
-
-  test("respects depth", async () => {
-    const results = await collect({ depth: 2 })
-    expect(results).toContain("index.md")
-    expect(results).toContain("user/")
-    expect(results.some((r) => r.startsWith("user/") && r.endsWith(".md"))).toBe(true)
-    expect(results.some((r) => r.includes("decisions/"))).toBe(false)
-  })
-
-  test("depth 1 only shows root contents", async () => {
-    const results = await collect({ depth: 1 })
-    expect(results).toContain("index.md")
-    expect(results).toContain("user/")
-    expect(results.every((r) => !r.includes("/") || r.endsWith("/"))).toBe(true)
-  })
-
-  test("skips hidden files and dirs by default", async () => {
-    const results = await collect()
-    expect(results.every((r) => !r.startsWith("."))).toBe(true)
-    expect(results.every((r) => !r.includes("/."))).toBe(true)
-    expect(results.some((r) => r.includes(".rekal"))).toBe(false)
-  })
-
-  test("includes hidden files when hidden is true", async () => {
-    const results = await collect({ depth: 1, hidden: true })
-    expect(results.length).toBeGreaterThan(0)
-  })
-
-  test("type=files excludes directories from output", async () => {
-    const results = await collect({ type: "file" })
-    expect(results.every((r) => !r.endsWith("/"))).toBe(true)
-    expect(results.some((r) => r.includes("/"))).toBe(true)
-  })
-})
-
-describe("glob patterns", () => {
-  test("filters to matching files only", async () => {
-    const results = await collect({ glob: "**/*.md" })
-    const files = results.filter((r) => !r.endsWith("/"))
-    expect(files.length).toBeGreaterThan(0)
-    expect(files.every((r) => r.endsWith(".md"))).toBe(true)
-  })
-
-  test("excludes non-matching files", async () => {
-    const results = await collect({ glob: "**/*.md" })
-    expect(results.some((r) => r.endsWith(".yaml"))).toBe(false)
-  })
-
-  test("still includes directories for traversal", async () => {
-    const results = await collect({ glob: "**/*.md" })
-    expect(results.some((r) => r.endsWith("/"))).toBe(true)
-  })
-
-  test("supports multiple glob patterns", async () => {
-    const results = await collect({ glob: ["**/family.md", "**/profile.md"] })
-    expect(results.some((r) => r.endsWith("family.md"))).toBe(true)
-    expect(results.some((r) => r.endsWith("profile.md"))).toBe(true)
-  })
-
-  test("narrow glob reduces results", async () => {
-    const allMd = await collect({ glob: "**/*.md" })
-    const userOnly = await collect({ glob: "user/*.md" })
-    expect(userOnly.length).toBeLessThan(allMd.length)
-    const files = userOnly.filter((r) => !r.endsWith("/"))
-    expect(files.every((r) => r.startsWith("user/"))).toBe(true)
-  })
-})
-
-describe("glob empty directories", () => {
-  test("excludes empty directories by default", async () => {
-    const results = await collect()
-    expect(results.some((r) => r === "empty-dir/")).toBe(false)
-  })
-
-  test("includes empty directories when empty is true", async () => {
-    const results = await collect({ empty: true })
-    expect(results.some((r) => r === "empty-dir/")).toBe(true)
-  })
-})
-
-describe("glob onVisit", () => {
-  test("calls onVisit for entries", async () => {
-    const visited: string[] = []
-    await collect({ onVisit: (rel) => visited.push(rel) })
-    expect(visited.length).toBeGreaterThan(0)
-  })
-})
-
-describe("glob onError", () => {
-  test("calls onError for inaccessible directories", async () => {
-    const errors: { path: string; error: Error }[] = []
-    await collect({
-      cwd: "/nonexistent-path-that-does-not-exist",
-      onError: (path, error) => errors.push({ error, path }),
-    })
-    expect(errors.length).toBeGreaterThan(0)
-  })
-})
-
-describe("glob sort", () => {
-  test("type sort puts directories before files", async () => {
-    const results = await collect({ depth: 1, sort: "type" })
-    const firstFile = results.findIndex((r) => !r.endsWith("/"))
-    const lastDir = results.findLastIndex((r) => r.endsWith("/"))
-    if (firstFile !== -1 && lastDir !== -1) {
-      expect(lastDir).toBeLessThan(firstFile)
-    }
-  })
-
-  test("name sort is alphabetical", async () => {
-    const results = await collect({ depth: 1, sort: "name" })
-    const sorted = [...results].toSorted()
-    expect(results).toEqual(sorted)
-  })
-})
-
-describe("glob ignore", () => {
-  test("respects exclude rules", async () => {
-    const results = await collect({ exclude: ["user/"] })
-    expect(results.some((r) => r.startsWith("user/"))).toBe(false)
-    expect(results.some((r) => r === "user/")).toBe(false)
-    expect(results.some((r) => r.startsWith("projects/"))).toBe(true)
-  })
-
-  test("ignore=false skips all ignore file processing", async () => {
-    const withIgnore = await collect()
-    const withoutIgnore = await collect({ hidden: true, ignore: false })
-    expect(withoutIgnore.length).toBeGreaterThanOrEqual(withIgnore.length)
-  })
-})
-
-describe("glob nested ignore files", () => {
-  const IGNORE_FIXTURES = join(fileURLToPath(import.meta.url), "..", "fixtures/ignore-test")
-
-  async function collectIgnore(opts: Partial<Parameters<typeof glob>[0]> = {}) {
-    const results: string[] = []
-    for await (const path of glob({ cwd: IGNORE_FIXTURES, ...opts })) {
-      results.push(path)
-    }
-    return results
-  }
-
-  test("nested gitignore with / prefix only applies relative to its directory", async () => {
-    // sub/.gitignore contains "/skip.log"
-    // This should ignore sub/skip.log but NOT skip.log at the root
-    const results = await collectIgnore({ hidden: false })
-    expect(results).toContain("skip.log") // root skip.log should NOT be ignored
-    expect(results).not.toContain("sub/skip.log") // sub/skip.log SHOULD be ignored
-    expect(results).toContain("keep.md")
-    expect(results).toContain("sub/keep.md")
-  })
-})

package/test/md.test.ts

@@ -1,177 +0,0 @@
-import { describe, expect, test } from "vitest"
-import { chunkMarkdown, parseSections } from "../src/md.ts"
-
-describe("parse", () => {
-  test("parses sections by heading", () => {
-    const sections = parseSections(`# Title
-
-Intro paragraph.
-
-## Section One
-
-Content one.
-
-## Section Two
-
-Content two.
-`)
-    expect(sections).toHaveLength(3)
-    expect(sections[0].headingText).toBe("# Title")
-    expect(sections[0].level).toBe(1)
-    expect(sections[1].headingText).toBe("## Section One")
-    expect(sections[1].level).toBe(2)
-    expect(sections[2].headingText).toBe("## Section Two")
-    expect(sections[2].level).toBe(2)
-  })
-
-  test("handles content before first heading", () => {
-    const sections = parseSections(`Some preamble text.
-
-# First Heading
-
-Content.
-`)
-    expect(sections).toHaveLength(2)
-    expect(sections[0].headingText).toBe("")
-    expect(sections[0].level).toBe(0)
-    expect(sections[0].content.join("\n")).toContain("preamble")
-  })
-
-  test("ignores headings inside code blocks", () => {
-    const sections = parseSections(`# Real Heading
-
-\`\`\`markdown
-# Not a heading
-## Also not a heading
-\`\`\`
-
-More content.
-`)
-    expect(sections).toHaveLength(1)
-    expect(sections[0].headingText).toBe("# Real Heading")
-    expect(sections[0].content.join("\n")).toContain("# Not a heading")
-  })
-
-  test("handles tilde code fences", () => {
-    const sections = parseSections(`# Title
-
-~~~python
-# comment not a heading
-~~~
-
-## Next Section
-
-Content.
-`)
-    expect(sections).toHaveLength(2)
-    expect(sections[0].headingText).toBe("# Title")
-    expect(sections[1].headingText).toBe("## Next Section")
-  })
-
-  test("discards empty sections", () => {
-    // A section with a heading but no content lines (immediately followed by another heading)
-    const sections = parseSections(`# First
-## Second
-
-Content here.
-`)
-    // "First" has "## Second" as its only content line before being replaced,
-    // but parse() keeps sections that have the heading line itself as content
-    expect(sections).toHaveLength(2)
-    expect(sections[0].headingText).toBe("# First")
-    expect(sections[1].headingText).toBe("## Second")
-  })
-
-  test("handles nested heading levels", () => {
-    const sections = parseSections(`# H1
-
-## H2
-
-### H3
-
-Content.
-
-## Another H2
-
-More content.
-`)
-    expect(sections.map((s) => s.headingText)).toEqual(["# H1", "## H2", "### H3", "## Another H2"])
-    expect(sections.map((s) => s.level)).toEqual([1, 2, 3, 2])
-  })
-})
-
-describe("chunk", () => {
-  // Simple mock tokenizer that counts words as tokens
-  const mockTokenizer = {
-    toks: (text: string) => text.split(/\s+/).filter(Boolean).length,
-  } as Parameters<typeof chunkMarkdown>[1]
-
-  test("small document produces single chunk", () => {
-    const result = chunkMarkdown("# Title\n\nShort content.", mockTokenizer, 100)
-    expect(result).toHaveLength(1)
-    expect(result[0]).toContain("Title")
-    expect(result[0]).toContain("Short content.")
-  })
-
-  test("splits at section boundaries", () => {
-    const md = `# Title
-
-First section with enough words to take some space in the chunk budget.
-
-## Second Section
-
-Second section content that should go into a new chunk because of size limits.
-`
-    const result = chunkMarkdown(md, mockTokenizer, 15)
-    expect(result.length).toBeGreaterThan(1)
-  })
-
-  test("includes parent headings in child chunks", () => {
-    const md = `# Parent
-
-## Child
-
-Child content that is long enough to be its own chunk separate from the parent section.
-`
-    const result = chunkMarkdown(md, mockTokenizer, 15)
-    // The child chunk should include "# Parent" for context
-    const childChunk = result.find((c) => c.includes("Child content"))
-    expect(childChunk).toContain("# Parent")
-  })
-
-  test("handles deeply nested headings", () => {
-    const md = `# Level 1
-
-## Level 2
-
-### Level 3
-
-Deep content that needs all its parent headings for context.
-`
-    const result = chunkMarkdown(md, mockTokenizer, 20)
-    const deepChunk = result.find((c) => c.includes("Deep content"))
-    expect(deepChunk).toBeDefined()
-    if (deepChunk) {
-      expect(deepChunk).toContain("# Level 1")
-      expect(deepChunk).toContain("## Level 2")
-    }
-  })
-
-  test("does not duplicate headings when packing siblings", () => {
-    const md = `# Parent
-
-## Child A
-
-Short A.
-
-## Child B
-
-Short B.
-`
-    const result = chunkMarkdown(md, mockTokenizer, 100)
-    // Both children fit in one chunk, parent heading should appear only once
-    expect(result).toHaveLength(1)
-    const count = result[0].split("# Parent").length - 1
-    expect(count).toBe(1)
-  })
-})

package/test/query.test.ts

@@ -1,105 +0,0 @@
-// 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

@@ -1,46 +0,0 @@
-// 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

@@ -1,62 +0,0 @@
-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" })
-  })
-})