kennel 0.2.13 → 0.2.15

package/kernel/packages/schemas/test/fields.test.mjs

@@ -1,187 +0,0 @@
-import assert from "node:assert/strict"
-import test from "node:test"
-
-import { expandAllFilters } from "../src/data/fields.ts"
-
-let id = 0
-const record = (fields) => ({
-  id: String(id++),
-  path: "record.md",
-  relativePath: "record.md",
-  title: "Record",
-  modifiedAt: 0,
-  fields,
-  validationErrors: [],
-})
-
-const collection = (records, filters = "all") => ({
-  id: "test",
-  folder: "/tmp/test",
-  schemaPath: "/tmp/test/schema.json",
-  title: "Test",
-  count: records.length,
-  diagnostics: [],
-  revision: "rev",
-  indexedAt: "2026-01-01T00:00:00.000Z",
-  state: "ready",
-  ui: { primaryField: "title", filters },
-  records,
-})
-
-test("all filters expands to the union of indexed record field names", () => {
-  const filters = expandAllFilters(
-    collection([
-      record({ status: "active", city: "Athens" }),
-      record({ stage: "seed", status: "active" }),
-      record({ city: "Athens", stage: "seed" }),
-    ]),
-  )
-
-  console.log("expanded filters union", filters)
-  assert.deepEqual(filters, ["status", "city", "stage"])
-})
-
-test("all filters excludes guarded values and schema formats", () => {
-  const filters = expandAllFilters(
-    collection([
-      record({
-        good: "yes",
-        longText: "x".repeat(81),
-        website: "https://example.com",
-        contact: "team@example.com",
-        dateBySchema: "2026-01-01",
-        arrayValue: ["a"],
-        objectValue: { nested: true },
-        uniqueCode: "one",
-      }),
-      record({
-        good: "yes",
-        longText: "short",
-        website: "none",
-        contact: "none",
-        dateBySchema: "2026-01-02",
-        arrayValue: "a",
-        objectValue: "flat",
-        uniqueCode: "two",
-      }),
-    ]),
-    {
-      type: "object",
-      properties: {
-        dateBySchema: { type: "string", format: "date" },
-      },
-    },
-  )
-
-  console.log("expanded filters exclusions", filters)
-  assert.deepEqual(filters, ["good"])
-})
-
-test("all filters excludes fields where every non-null value is unique", () => {
-  const filters = expandAllFilters(
-    collection([
-      record({ repeated: "same", unique: "one", partlyNull: null }),
-      record({ repeated: "same", unique: "two", partlyNull: "only" }),
-      record({ repeated: "other", unique: "three" }),
-    ]),
-  )
-
-  console.log("expanded filters unique guard", filters)
-  assert.deepEqual(filters, ["repeated"])
-})
-
-test("explicit filter lists are preserved without guards or reordering", () => {
-  const filters = expandAllFilters(
-    collection(
-      [
-        record({
-          website: "https://example.com",
-          contact: "team@example.com",
-          status: "active",
-        }),
-      ],
-      ["contact", "website", "status"],
-    ),
-  )
-
-  console.log("explicit filters preserved", filters)
-  assert.deepEqual(filters, ["contact", "website", "status"])
-})
-
-test("all filters excludes repeated guarded values without relying on uniqueness", () => {
-  const filters = expandAllFilters(
-    collection([
-      record({
-        ok: "same",
-        uri: "https://example.com",
-        email: "team@example.com",
-        tel: "tel:+302100000000",
-        array: ["same"],
-        object: { value: "same" },
-      }),
-      record({
-        ok: "same",
-        uri: "https://example.com",
-        email: "team@example.com",
-        tel: "tel:+302100000000",
-        array: ["same"],
-        object: { value: "same" },
-      }),
-    ]),
-  )
-
-  assert.deepEqual(filters, ["ok"])
-})
-
-test("all filters excludes schema format guards with repeated safe-looking strings", () => {
-  const filters = expandAllFilters(
-    collection([
-      record({
-        ok: "same",
-        uriField: "plain",
-        emailField: "plain",
-        dateField: "plain",
-      }),
-      record({
-        ok: "same",
-        uriField: "plain",
-        emailField: "plain",
-        dateField: "plain",
-      }),
-    ]),
-    {
-      properties: {
-        uriField: { type: "string", format: "uri" },
-        emailField: { type: "string", format: "email" },
-        dateField: { type: "string", format: "date" },
-      },
-    },
-  )
-
-  assert.deepEqual(filters, ["ok"])
-})
-
-test("all filters applies length guard on later records and keeps 80 character values", () => {
-  const eighty = "x".repeat(80)
-  const eightyOne = "x".repeat(81)
-  const filters = expandAllFilters(
-    collection([
-      record({ ok: "same", boundary: eighty, laterLong: "same" }),
-      record({ ok: "same", boundary: eighty, laterLong: eightyOne }),
-      record({ ok: "other", boundary: eighty, laterLong: "same" }),
-    ]),
-  )
-
-  assert.deepEqual(filters, ["ok", "boundary"])
-})
-
-test("all filters handles null-only, numeric and boolean repeated values", () => {
-  const filters = expandAllFilters(
-    collection([
-      record({ nullOnly: null, count: 2, enabled: true }),
-      record({ nullOnly: null, count: 2, enabled: true }),
-    ]),
-  )
-
-  assert.deepEqual(filters, ["count", "enabled"])
-})

package/kernel/packages/schemas/test/load.test.mjs

@@ -1,12 +0,0 @@
-import assert from "node:assert/strict"
-import test from "node:test"
-
-import { normaliseKennelConfig } from "../src/data/load.ts"
-
-test("normalization distinguishes omitted sort from defined empty sort", () => {
-  assert.equal(normaliseKennelConfig({}).ui.sort, undefined)
-  assert.deepEqual(
-    normaliseKennelConfig({ "x-kennel": { ui: { sort: [] } } }).ui.sort,
-    [],
-  )
-})

package/kernel/packages/schemas/test/node.test.mjs

@@ -1,412 +0,0 @@
-import assert from "node:assert/strict"
-import {
-  mkdir,
-  mkdtemp,
-  realpath,
-  rm,
-  symlink,
-  unlink,
-  utimes,
-  writeFile,
-} from "node:fs/promises"
-import { createServer } from "node:http"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import test from "node:test"
-
-import { collectionSummary } from "@raggle-ai/schemas"
-
-import { createCoreFolderIndex } from "../src/node.ts"
-
-async function fixture(
-  t,
-  documents = [{ glob: "*.md", parser: "markdown-frontmatter" }],
-) {
-  const root = await realpath(await mkdtemp(join(tmpdir(), "core-index-")))
-  t.after(() => rm(root, { recursive: true, force: true }))
-  for (const name of ["startups", "meetups"]) {
-    await mkdir(join(root, name))
-    await writeFile(
-      join(root, name, "schema.json"),
-      JSON.stringify({
-        $schema: "https://json-schema.org/draft/2020-12/schema",
-        title: name,
-        type: "object",
-        required: ["title"],
-        properties: { title: { type: "string" } },
-        "x-kennel": {
-          icon: "rocket",
-          documents,
-          ui: {
-            primaryField: "title",
-            navLabel: "Short",
-            filters: ["status"],
-            sort: [{ field: "title", direction: "asc" }],
-          },
-        },
-      }),
-    )
-    await writeFile(
-      join(root, name, "a.md"),
-      "---\r\ntitle: Alpha\r\nstatus: active\r\n---\r\n# Body\n",
-    )
-  }
-  await writeFile(
-    join(root, "raggle.json"),
-    JSON.stringify({
-      schemas: [
-        { path: "startups", schema: "startups/schema.json" },
-        { path: "meetups", schema: "meetups/schema.json" },
-      ],
-    }),
-  )
-  return { root, index: createCoreFolderIndex() }
-}
-
-test("file modification time is indexed and refreshed without frontmatter edits", async (t) => {
-  const { root, index } = await fixture(t)
-  const file = join(root, "startups/a.md")
-  await utimes(file, 1000, 1000)
-  const first = (await index.list(root)).collections[0]
-  assert.equal(first.records[0].modifiedAt, 1000000)
-  assert.deepEqual(first.ui.sort, [{ field: "title", direction: "asc" }])
-  await utimes(file, 2000, 2000)
-  index.invalidate(file)
-  const next = (await index.list(root)).collections[0]
-  assert.equal(next.records[0].modifiedAt, 2000000)
-  assert.notEqual(next.revision, first.revision)
-})
-
-test("shared index has stable relative IDs, metadata, validation and lean summaries", async (t) => {
-  const { root, index } = await fixture(t)
-  await writeFile(
-    join(root, "startups/bad.md"),
-    "---\nstatus: active\n---\n# Untitled\n",
-  )
-  const result = await index.list(root)
-  const collection = result.collections[0]
-  assert.equal(collection.id, "startups")
-  assert.equal(collection.count, 2)
-  assert.equal(collection.icon, "rocket")
-  assert.equal(collection.navLabel, "Short")
-  assert.equal(collection.records[0].title, "Alpha")
-  assert.equal(collection.records[0].id, "startups/a.md")
-  assert.equal(collection.records[1].validationErrors.length, 1)
-  assert.equal(collectionSummary(collection).records, undefined)
-  assert.match(result.revision, /^[a-f0-9]{64}$/)
-})
-
-test("cache rereads only changed records and affected collections; additions and deletion refresh counts", async (t) => {
-  const { root, index } = await fixture(t)
-  const first = await index.list(root)
-  await index.list(root)
-  assert.deepEqual(index.stats, { collectionsBuilt: 2, recordsRead: 2 })
-  const file = join(root, "startups/a.md")
-  await writeFile(file, "---\ntitle: Updated\n---\n")
-  assert.deepEqual(index.invalidate(file), [root])
-  const updated = await index.list(root)
-  assert.equal(updated.collections[0].records[0].title, "Updated")
-  assert.equal(updated.collections[1], first.collections[1])
-  assert.notEqual(updated.revision, first.revision)
-  assert.deepEqual(index.stats, { collectionsBuilt: 3, recordsRead: 3 })
-  const added = join(root, "startups/new.md")
-  await writeFile(added, "---\ntitle: New\n---\n")
-  index.invalidate(added)
-  assert.equal((await index.list(root)).collections[0].count, 2)
-  await unlink(added)
-  index.invalidate(added)
-  assert.equal((await index.list(root)).collections[0].count, 1)
-})
-
-test("schema edits rebuild metadata and validation without rereading unchanged records", async (t) => {
-  const { root, index } = await fixture(t)
-  await index.list(root)
-  const schema = join(root, "startups/schema.json")
-  await writeFile(
-    schema,
-    JSON.stringify({ title: "Renamed", type: "object", required: ["missing"] }),
-  )
-  index.invalidate(schema)
-  const updated = (await index.list(root)).collections[0]
-  assert.equal(updated.title, "Renamed")
-  assert.equal(updated.records[0].validationErrors.length, 1)
-  assert.equal(index.stats.recordsRead, 2)
-})
-
-test("document scopes support recursive globs and paths; shallow patterns don't traverse child directories", async (t) => {
-  const { root, index } = await fixture(t, [
-    { path: "**/*.md", parser: "markdown-frontmatter" },
-  ])
-  await mkdir(join(root, "startups/deep"))
-  await writeFile(join(root, "startups/deep/note.md"), "# Deep\n")
-  const result = await index.list(root)
-  assert.equal(result.collections[0].count, 2)
-  assert.equal(result.collections[0].records[1].relativePath, "deep/note.md")
-})
-
-test("a remote $ref wrapper schema resolves over HTTP and validates records", async (t) => {
-  const server = createServer((request, response) => {
-    if (request.url === "/schemas/people.json") {
-      response.setHeader("content-type", "application/json")
-      response.end(
-        JSON.stringify({
-          $schema: "https://json-schema.org/draft/2020-12/schema",
-          $id: `http://127.0.0.1:${server.address().port}/schemas/people.json`,
-          title: "People",
-          type: "object",
-          required: ["name"],
-          properties: {
-            name: { type: "string", minLength: 1 },
-            role: { type: "string" },
-          },
-          "x-kennel": {
-            ui: {
-              primaryField: "name",
-              secondaryField: "role",
-              filters: ["status"],
-            },
-          },
-        }),
-      )
-      return
-    }
-    response.statusCode = 404
-    response.end("not found")
-  })
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve))
-  t.after(() => server.close())
-  const { root, index } = await fixture(t)
-  await mkdir(join(root, "people"))
-  const schemaUrl = `http://127.0.0.1:${server.address().port}/schemas/people.json`
-  await writeFile(
-    join(root, "people/schema.json"),
-    JSON.stringify({
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      $ref: schemaUrl,
-    }),
-  )
-  await writeFile(
-    join(root, "people/a.md"),
-    "---\r\nname: Alice\r\nrole: Contractor\r\nstatus: active\r\n---\r\n# Body\n",
-  )
-  await writeFile(
-    join(root, "people/bad.md"),
-    "---\r\nrole: Missing name\r\n---\r\n# Untitled\n",
-  )
-  await writeFile(
-    join(root, "raggle.json"),
-    JSON.stringify({
-      schemas: [
-        { path: "startups", schema: "startups/schema.json" },
-        { path: "people", schema: "people/schema.json" },
-      ],
-    }),
-  )
-  const result = await index.list(root)
-  const collection = result.collections.find((entry) => entry.id === "people")
-  assert.equal(collection.state, "ready")
-  assert.deepEqual(collection.diagnostics, [])
-  assert.equal(collection.count, 2)
-  assert.equal(collection.ui.primaryField, "name")
-  assert.equal(collection.ui.filters[0], "status")
-  assert.equal(collection.records[0].title, "Alice")
-  assert.equal(collection.records[1].validationErrors.length, 1)
-  assert.match(
-    collection.records[1].validationErrors[0].message,
-    /must have required property/i,
-  )
-})
-
-test("public loader normalizes ui sort and wildcard filters", async (t) => {
-  const { root, index } = await fixture(t)
-  await writeFile(
-    join(root, "startups/schema.json"),
-    JSON.stringify({
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      title: "startups",
-      type: "object",
-      properties: {
-        status: { type: "string" },
-        website: { type: "string", format: "uri" },
-        contact: { type: "string", format: "email" },
-        launched: { type: "string", format: "date" },
-      },
-      "x-kennel": {
-        documents: [{ glob: "*.md", parser: "markdown-frontmatter" }],
-        ui: {
-          primaryField: "title",
-          filters: "all",
-          sort: [
-            { field: "status", direction: "asc" },
-            { field: "title", direction: "desc" },
-          ],
-        },
-      },
-    }),
-  )
-  await writeFile(
-    join(root, "startups/a.md"),
-    "---\ntitle: Alpha\nstatus: active\ncity: Athens\nstage: seed\nuniqueCode: one\nwebsite: https://example.com\ncontact: team@example.com\nlaunched: 2026-01-01\ntags:\n  - ai\nmeta:\n  owner: raggle\n---\n",
-  )
-  await writeFile(
-    join(root, "startups/b.md"),
-    "---\ntitle: Beta\nstatus: active\ncity: Athens\nstage: seed\nuniqueCode: two\nwebsite: none\ncontact: none\nlaunched: 2026-01-02\ntags: ai\nmeta: flat\n---\n",
-  )
-  index.invalidate(join(root, "startups/schema.json"))
-
-  const collection = (await index.list(root)).collections.find(
-    (entry) => entry.id === "startups",
-  )
-  console.log("normalized ui.filters", collection.ui.filters)
-  console.log("normalized ui.sort", collection.ui.sort)
-  assert.deepEqual(collection.ui.filters, ["status", "city", "stage"])
-  assert.deepEqual(collection.ui.sort, [
-    { field: "status", direction: "asc" },
-    { field: "title", direction: "desc" },
-  ])
-})
-
-test("public loader preserves explicit filter lists and defined empty sort", async (t) => {
-  const { root, index } = await fixture(t)
-  await writeFile(
-    join(root, "startups/schema.json"),
-    JSON.stringify({
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      title: "startups",
-      type: "object",
-      "x-kennel": {
-        documents: [{ glob: "*.md", parser: "markdown-frontmatter" }],
-        ui: {
-          primaryField: "title",
-          filters: ["website", "missing", "website", "status"],
-          sort: [],
-        },
-      },
-    }),
-  )
-  await writeFile(
-    join(root, "startups/a.md"),
-    "---\ntitle: Alpha\nstatus: active\nwebsite: https://example.com\n---\n",
-  )
-  index.invalidate(join(root, "startups/schema.json"))
-
-  const collection = (await index.list(root)).collections.find(
-    (entry) => entry.id === "startups",
-  )
-  console.log("explicit normalized ui.filters", collection.ui.filters)
-  console.log("empty normalized ui.sort", collection.ui.sort)
-  assert.deepEqual(collection.ui.filters, [
-    "website",
-    "missing",
-    "website",
-    "status",
-  ])
-  assert.deepEqual(collection.ui.sort, [])
-})
-
-test("remote $ref wrappers surface a diagnostic when the reference is unreachable", async (t) => {
-  const server = createServer((_request, response) => {
-    response.statusCode = 404
-    response.end("not found")
-  })
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve))
-  t.after(() => server.close())
-  const { root, index } = await fixture(t)
-  const schemaUrl = `http://127.0.0.1:${server.address().port}/schemas/absent.json`
-  await mkdir(join(root, "people"))
-  await writeFile(
-    join(root, "people/schema.json"),
-    JSON.stringify({
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      $ref: schemaUrl,
-    }),
-  )
-  await writeFile(
-    join(root, "raggle.json"),
-    JSON.stringify({
-      schemas: [{ path: "people", schema: "people/schema.json" }],
-    }),
-  )
-  const result = await index.list(root)
-  assert.equal(result.state, "error")
-  assert.match(
-    result.collections[0].diagnostics[0].message,
-    /Failed to fetch referenced schema/,
-  )
-  assert.equal(result.collections[0].count, 0)
-})
-
-test("invalid schemas and unsupported parsers surface diagnostics rather than silently indexing everything", async (t) => {
-  const { root, index } = await fixture(t, [
-    { glob: "*.md", parser: "unknown" },
-  ])
-  await writeFile(join(root, "meetups/schema.json"), "not JSON")
-  const result = await index.list(root)
-  assert.equal(result.state, "error")
-  assert.match(
-    result.collections[0].diagnostics[0].message,
-    /Unsupported parser/,
-  )
-  assert.equal(result.collections[0].count, 0)
-  assert.equal(result.collections[1].count, 0)
-  await unlink(join(root, "meetups/schema.json"))
-  index.invalidate(join(root, "meetups/schema.json"))
-  assert.equal((await index.list(root)).collections[1].state, "error")
-})
-
-test("index rejects collection-root symlink escapes and doesn't follow record symlinks", async (t) => {
-  const { root, index } = await fixture(t)
-  const outside = await realpath(
-    await mkdtemp(join(tmpdir(), "index-outside-")),
-  )
-  t.after(() => rm(outside, { recursive: true, force: true }))
-  await writeFile(join(outside, "secret.md"), "# Secret")
-  await symlink(join(outside, "secret.md"), join(root, "startups/link.md"))
-  assert.equal((await index.list(root)).collections[0].count, 1)
-  await symlink(outside, join(root, "escape"))
-  await writeFile(
-    join(root, "raggle.json"),
-    JSON.stringify({
-      schemas: [{ path: "escape", schema: "startups/schema.json" }],
-    }),
-  )
-  index.invalidate(join(root, "raggle.json"))
-  const escaped = (await index.list(root)).collections[0]
-  assert.equal(escaped.state, "error")
-  assert.equal(escaped.records.length, 0)
-})
-
-test("adding a local schema invalidates an initially untyped folder", async (t) => {
-  const { root, index } = await fixture(t)
-  const folder = join(root, "untyped")
-  await mkdir(folder)
-  assert.equal((await index.list(folder)).collections.length, 0)
-  const schema = join(folder, "schema.json")
-  await writeFile(
-    schema,
-    JSON.stringify({ title: "New collection", type: "object" }),
-  )
-  assert.deepEqual(index.invalidate(schema), [folder])
-  assert.equal(
-    (await index.list(folder)).collections[0].title,
-    "New collection",
-  )
-})
-
-test("configuration edits add and remove collections, including initially empty workspaces", async (t) => {
-  const { root, index } = await fixture(t)
-  const config = join(root, "raggle.json")
-  await writeFile(config, "{}")
-  assert.equal((await index.list(root)).collections.length, 0)
-  await writeFile(
-    config,
-    JSON.stringify({
-      schemas: [{ path: "startups", schema: "startups/schema.json" }],
-    }),
-  )
-  assert.deepEqual(index.invalidate(config), [root])
-  assert.equal((await index.list(root)).collections.length, 1)
-  await writeFile(config, "{}")
-  index.invalidate(config)
-  assert.equal((await index.list(root)).collections.length, 0)
-})