kennel 0.2.1 → 0.2.2

package/kernel/plugins/calendar/test/context.test.mjs

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import { dayContext, eventContext } from "../src/context.ts"
+
+const event = {
+  id: "daily:2026-09-16",
+  title: "Daily Operations Check-in",
+  start: new Date("2026-09-16T08:30:00Z"),
+  end: new Date("2026-09-16T08:45:00Z"),
+  allDay: false,
+  attendees: ["the maintainer", "Operations team"],
+  color: "blue",
+  description: "Review the important tasks for today.",
+  excludeDates: [new Date("2026-09-20T00:00:00Z")],
+  group: "Operations",
+  location: "Operations room",
+  organizer: "Example Workspace",
+  reminders: [0, 15],
+  repeating: "daily",
+  repeatUntil: new Date("2026-12-31T23:59:59Z"),
+  status: "confirmed",
+  tags: ["operations", "daily"],
+  url: "https://example.com/example-workspace/check-in",
+}
+
+test("eventContext includes all event data for AI context", () => {
+  const context = eventContext(event)
+
+  for (const value of [
+    "Daily Operations Check-in",
+    "daily:2026-09-16",
+    "2026-09-16T08:30:00.000Z",
+    "All day: No",
+    "Group: Operations",
+    "Status: confirmed",
+    "Operations room",
+    "Example Workspace",
+    "the maintainer, Operations team",
+    "Repeats: daily",
+    "2026-09-20T00:00:00.000Z",
+    "at start, 15 minutes before",
+    "operations, daily",
+    "Color: blue",
+    "https://example.com/example-workspace/check-in",
+    "Review the important tasks for today.",
+  ]) {
+    assert.ok(context.includes(value), `missing context value: ${value}`)
+  }
+})
+
+test("dayContext includes the selected date and its events", () => {
+  const context = dayContext(new Date("2026-09-16T12:00:00Z"), [event])
+  assert.match(context, /^# Calendar context for /)
+  assert.match(context, /Daily Operations Check-in/)
+})
+
+test("dayContext explains an empty day", () => {
+  assert.match(dayContext(new Date("2026-09-18T12:00:00Z"), []), /No events\.$/)
+})

package/kernel/plugins/calendar/test/package.test.mjs

@@ -0,0 +1,43 @@
+import assert from "node:assert/strict"
+import { readFile } from "node:fs/promises"
+import test from "node:test"
+
+const packageJson = JSON.parse(
+  await readFile(new URL("../package.json", import.meta.url), "utf8"),
+)
+
+test("calendar package is ready for public npm publishing", () => {
+  assert.equal(packageJson.private, undefined)
+  assert.equal(packageJson.version, "0.1.0")
+  assert.equal(packageJson.license, "MIT")
+  assert.equal(packageJson.publishConfig?.access, "public")
+  assert.equal(packageJson.repository?.directory, "plugins/calendar")
+  assert.deepEqual(packageJson.files, ["src"])
+})
+
+test("calendar package exposes parser, component, manifest, and split server/client entry points", () => {
+  assert.deepEqual(Object.keys(packageJson.exports).sort(), [
+    ".",
+    "./calendar",
+    "./client",
+    "./context",
+    "./manifest",
+    "./parse",
+    "./server",
+  ])
+})
+
+test("calendar client entry does not import the Node server entry", async () => {
+  const clientSource = await readFile(
+    new URL("../src/client.tsx", import.meta.url),
+    "utf8",
+  )
+  assert.doesNotMatch(clientSource, /node:|\/server"/)
+})
+
+test("calendar package uses the shared ui folder filter", () => {
+  const dependencyNames = Object.keys(packageJson.dependencies ?? {})
+  // The calendar view filters merged nested calendars by folder via the
+  // shared `@raggle-ai/ui` folder filter; its issue panel stays local.
+  assert.ok(dependencyNames.includes("@raggle-ai/ui"))
+})

package/kernel/plugins/calendar/test/parse.test.mjs

@@ -0,0 +1,392 @@
+import assert from "node:assert/strict"
+import { readFile } from "node:fs/promises"
+import test from "node:test"
+
+import {
+  calendarIssueSummary,
+  eventCount,
+  eventsInRange,
+  mergeCalendars,
+  normalizeEvent,
+  parseCalendar,
+  parseCalendarJson,
+  parseCalendarSource,
+  parseEvents,
+  starterCalendarSource,
+  validateCalendarFile,
+} from "../src/parse.ts"
+
+const schema = JSON.parse(
+  await readFile(new URL("../schema.json", import.meta.url), "utf8"),
+)
+
+test("calendar schema publishes the repeating values", () => {
+  assert.equal(schema.$id, "https://raggle.co/schemas/calendar.json")
+  assert.deepEqual(schema.$defs.event.properties.repeating.enum, [
+    "daily",
+    "weekly",
+    "monthly",
+  ])
+})
+
+test("calendar schema supports document and event groups", () => {
+  assert.equal(schema.properties.group.type, "string")
+  assert.deepEqual(schema.properties.color.enum, [
+    "blue",
+    "green",
+    "red",
+    "yellow",
+    "purple",
+    "orange",
+  ])
+  assert.equal(schema.$defs.event.properties.group.type, "string")
+})
+
+test("calendar schema publishes ten enhanced event fields", () => {
+  const properties = schema.$defs.event.properties
+  assert.deepEqual(
+    [
+      "allDay",
+      "attendees",
+      "excludeDates",
+      "location",
+      "organizer",
+      "reminders",
+      "repeatUntil",
+      "status",
+      "tags",
+      "url",
+    ].filter((field) => properties[field]),
+    [
+      "allDay",
+      "attendees",
+      "excludeDates",
+      "location",
+      "organizer",
+      "reminders",
+      "repeatUntil",
+      "status",
+      "tags",
+      "url",
+    ],
+  )
+})
+
+test("parseCalendar accepts a top-level event array", () => {
+  const document = parseCalendar([
+    {
+      title: "Standup",
+      start: "2026-09-10T09:00:00",
+      end: "2026-09-10T09:30:00",
+    },
+  ])
+  assert.equal(eventCount(document), 1)
+  assert.equal(document?.events[0]?.title, "Standup")
+})
+
+test("parseCalendar accepts an object with an events key and title", () => {
+  const document = parseCalendar({
+    title: "Example Workspace",
+    events: [{ title: "VAT Return", date: "2026-09-16T00:00:00" }],
+  })
+  assert.equal(document?.title, "Example Workspace")
+  assert.equal(document?.events[0]?.title, "VAT Return")
+  assert.ok(document?.events[0]?.start instanceof Date)
+})
+
+test("normalizeEvent fills a missing end time with a one-hour default", () => {
+  const event = normalizeEvent(
+    { title: "Check-in", start: "2026-09-10T10:00:00" },
+    0,
+  )
+  assert.equal(event.end.getTime() - event.start.getTime(), 3_600_000)
+})
+
+test("normalizeEvent maps startDate and endDate variants", () => {
+  const event = normalizeEvent(
+    { title: "Review", startDate: "2026-09-11", endDate: "2026-09-12" },
+    1,
+  )
+  assert.equal(event.title, "Review")
+  assert.ok(event.start instanceof Date)
+  assert.ok(event.end > event.start)
+})
+
+test("normalizeEvent keeps non-date events valid", () => {
+  const events = parseEvents([{ title: "No dates here" }])
+  assert.equal(events[0]?.title, "No dates here")
+  assert.ok(events[0]?.start instanceof Date)
+  assert.ok(events[0]?.end instanceof Date)
+  assert.ok(events[0]?.end > events[0]?.start)
+})
+
+test("parseEvents restores Date objects from serialized metadata", () => {
+  const serialized = JSON.parse(
+    JSON.stringify([
+      { title: "VAT Return", start: new Date("2026-09-16T00:00:00") },
+    ]),
+  )
+
+  const [event] = parseEvents(serialized)
+  assert.ok(event)
+  assert.equal(event.title, "VAT Return")
+  assert.ok(event.start instanceof Date, "start must be a Date, not a string")
+  assert.ok(event.end instanceof Date, "end must be a Date, not a string")
+  assert.equal(event.start.getTime(), new Date("2026-09-16T00:00:00").getTime())
+})
+
+test("normalizeEvent accepts daily, weekly, and monthly repeating values", () => {
+  for (const value of ["daily", "weekly", "monthly"]) {
+    assert.equal(
+      normalizeEvent({ repeating: value, start: "2026-09-01T09:00:00" }, 0)
+        .repeating,
+      value,
+    )
+  }
+  assert.equal(
+    normalizeEvent({ repeating: "yearly", start: "2026-09-01T09:00:00" }, 0)
+      .repeating,
+    undefined,
+  )
+})
+
+test("normalizeEvent reads all ten enhanced fields", () => {
+  const event = normalizeEvent(
+    {
+      allDay: true,
+      attendees: ["Alex", "Sam", "Alex", ""],
+      excludeDates: ["2026-09-17", "invalid"],
+      location: "Board room",
+      organizer: "Taylor",
+      reminders: [30, 0, 30, -1, 2.5],
+      repeatUntil: "2026-09-30",
+      start: "2026-09-16",
+      status: "tentative",
+      tags: ["finance", "quarterly", "finance"],
+      title: "Director review",
+      url: "https://example.com/review",
+    },
+    0,
+  )
+
+  assert.equal(event.allDay, true)
+  assert.equal(event.end.getTime() - event.start.getTime(), 86_400_000)
+  assert.deepEqual(event.attendees, ["Alex", "Sam"])
+  assert.deepEqual(
+    event.excludeDates?.map((date) => date.getDate()),
+    [17],
+  )
+  assert.equal(event.location, "Board room")
+  assert.equal(event.organizer, "Taylor")
+  assert.deepEqual(event.reminders, [0, 30])
+  assert.equal(event.repeatUntil?.getDate(), 30)
+  assert.equal(event.status, "tentative")
+  assert.deepEqual(event.tags, ["finance", "quarterly"])
+  assert.equal(event.url, "https://example.com/review")
+})
+
+test("repeatUntil and excludeDates limit repeating events", () => {
+  const event = normalizeEvent(
+    {
+      excludeDates: ["2026-09-03"],
+      repeating: "daily",
+      repeatUntil: "2026-09-04",
+      start: "2026-09-01T09:00:00",
+      title: "Check-in",
+    },
+    0,
+  )
+  const occurrences = eventsInRange(
+    [event],
+    new Date("2026-09-01T00:00:00"),
+    new Date("2026-09-06T00:00:00"),
+  )
+
+  assert.deepEqual(
+    occurrences.map((item) => item.start.getDate()),
+    [1, 2, 4],
+  )
+})
+
+test("eventsInRange expands daily, weekly, and monthly events", () => {
+  const events = parseEvents([
+    {
+      id: "daily",
+      repeating: "daily",
+      start: "2026-09-01T09:00:00",
+      end: "2026-09-01T09:30:00",
+    },
+    {
+      id: "weekly",
+      repeating: "weekly",
+      start: "2026-09-02T10:00:00",
+      end: "2026-09-02T10:30:00",
+    },
+    {
+      id: "monthly",
+      repeating: "monthly",
+      start: "2026-08-09T11:00:00",
+      end: "2026-08-09T11:30:00",
+    },
+  ])
+  const occurrences = eventsInRange(
+    events,
+    new Date("2026-09-09T00:00:00"),
+    new Date("2026-09-10T00:00:00"),
+  )
+  assert.deepEqual(
+    occurrences.map((event) => event.id.split(":")[0]),
+    ["daily", "weekly", "monthly"],
+  )
+  assert.ok(occurrences.every((event) => event.start instanceof Date))
+})
+
+test("validation accepts a valid object document", () => {
+  assert.deepEqual(
+    validateCalendarFile({
+      title: "Team",
+      events: [{ id: "1", title: "Standup", start: "2026-09-10T09:00:00" }],
+    }),
+    [],
+  )
+})
+
+test("validation accepts a top-level event array", () => {
+  assert.deepEqual(validateCalendarFile([{ title: "Standup" }]), [])
+})
+
+test("validation rejects non-object non-array documents", () => {
+  assert.deepEqual(validateCalendarFile("nope"), [
+    {
+      path: "#",
+      message: "calendar.json must contain an object or an array of events",
+    },
+  ])
+})
+
+test("validation rejects a missing events array", () => {
+  assert.deepEqual(validateCalendarFile({ title: "Team" }), [
+    { path: "events", message: "must be an array of events" },
+  ])
+})
+
+test("validation flags events without any title", () => {
+  const issues = validateCalendarFile({
+    events: [{ id: "1", start: "2026-09-10T09:00:00" }],
+  })
+  assert.equal(issues[0]?.path, "events[0]")
+  assert.match(issues[0]?.message ?? "", /has no title/)
+})
+
+test("validation flags unparseable start and end dates", () => {
+  const issues = validateCalendarFile({
+    events: [{ title: "Broken", start: "not-a-date", end: "also-bad" }],
+  })
+  assert.deepEqual(
+    issues.map((issue) => issue.path),
+    ["events[0].start", "events[0].end"],
+  )
+  assert.ok(
+    issues.every((issue) =>
+      /could not be parsed as a date/.test(issue.message),
+    ),
+  )
+})
+
+test("validation flags bad enums and non-boolean allDay", () => {
+  const issues = validateCalendarFile({
+    events: [
+      {
+        title: "One",
+        start: "2026-09-10T09:00:00",
+        allDay: "yes",
+        repeating: "yearly",
+        status: "maybe",
+      },
+    ],
+  })
+  assert.deepEqual(
+    issues.map((issue) => issue.path),
+    ["events[0].allDay", "events[0].repeating", "events[0].status"],
+  )
+})
+
+test("parseCalendarSource reports invalid JSON as an issue", () => {
+  const parsed = parseCalendarSource('{"events": [')
+  assert.equal(parsed.ok, false)
+  if (parsed.ok) return
+  assert.equal(parsed.issues[0]?.path, "#")
+  assert.match(parsed.issues[0]?.message ?? "", /not valid JSON/)
+})
+
+test("calendarIssueSummary is compact for nav badges", () => {
+  assert.equal(
+    calendarIssueSummary([{ path: "events[2].start", message: "bad date" }]),
+    "events[2].start: bad date",
+  )
+  assert.equal(
+    calendarIssueSummary([
+      { path: "events[0].start", message: "bad date" },
+      { path: "events[1].start", message: "bad date" },
+    ]),
+    "2 problems found in calendar.json (first: events[0].start — bad date)",
+  )
+})
+
+test("starter calendar source validates and parses", () => {
+  const source = starterCalendarSource()
+  const validation = parseCalendarSource(source)
+  assert.equal(validation.ok, true)
+  const document = parseCalendarJson(source)
+  assert.equal(eventCount(document), 1)
+  const parsed = parseCalendar(JSON.parse(source))
+  assert.equal(parsed?.events[0]?.title, "First event")
+})
+
+test("mergeCalendars combines nested files and assigns their groups", () => {
+  const merged = mergeCalendars([
+    {
+      calendar: parseCalendar({
+        color: "blue",
+        group: "Company",
+        title: "Example Workspace Calendar",
+        events: [{ title: "Check-in", start: "2026-09-16T08:30:00" }],
+      }),
+      folder: "/tmp/kennel-example/example-workspace",
+      group: "example-workspace",
+      path: "calendar.json",
+    },
+    {
+      calendar: parseCalendar({
+        color: "green",
+        group: "Accounting",
+        events: [{ title: "Payroll", start: "2026-09-16T10:00:00" }],
+      }),
+      folder: "/tmp/kennel-example/example-workspace/clients/client-one",
+      group: "accounting",
+      path: "accounting/calendar.json",
+    },
+  ])
+
+  assert.equal(merged.title, "Example Workspace Calendar")
+  assert.deepEqual(
+    merged.events.map((event) => [
+      event.title,
+      event.group,
+      event.groupColor,
+      event.id,
+    ]),
+    [
+      ["Check-in", "Company", "blue", "calendar.json:0"],
+      ["Payroll", "Accounting", "green", "accounting/calendar.json:0"],
+    ],
+  )
+  // Every merged event carries its owning folder for the shared folder filter.
+  assert.deepEqual(
+    merged.events.map((event) => event.folder),
+    [
+      "/tmp/kennel-example/example-workspace",
+      "/tmp/kennel-example/example-workspace/clients/client-one",
+    ],
+  )
+})

package/kernel/plugins/calendar/test/server.test.mjs

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict"
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import test from "node:test"
+
+import { createCalendarPlugin } from "../src/server.ts"
+
+const plugin = createCalendarPlugin()
+
+test("handle merges nested calendars and stamps each event's owning folder", async () => {
+  const folder = await mkdtemp(join(tmpdir(), "kennel-calendar-"))
+  try {
+    await writeFile(
+      join(folder, "calendar.json"),
+      JSON.stringify({
+        events: [{ title: "Root event", start: "2026-09-10T09:00:00" }],
+      }),
+    )
+    const nested = join(folder, "clients", "client-one")
+    await mkdir(nested, { recursive: true })
+    await writeFile(
+      join(nested, "calendar.json"),
+      JSON.stringify({
+        events: [{ title: "Nested event", start: "2026-09-11T09:00:00" }],
+      }),
+    )
+
+    const result = await plugin.handle({ folder }, "")
+    assert.equal(result.kind, "available")
+    if (result.kind !== "available") return
+    assert.equal(result.data.status, "available")
+    assert.equal(result.data.calendar.items.length, 2)
+    const folders = result.data.calendar.items
+      .map((event) => event.folder)
+      .sort()
+    assert.deepEqual(folders, [folder, nested].sort())
+  } finally {
+    await rm(folder, { recursive: true, force: true })
+  }
+})
+
+test("detect is unavailable without any calendar.json", async () => {
+  const folder = await mkdtemp(join(tmpdir(), "kennel-calendar-"))
+  try {
+    const detection = await plugin.detect({ folder })
+    assert.equal(detection.status, "unavailable")
+  } finally {
+    await rm(folder, { recursive: true, force: true })
+  }
+})
+
+test("detect is available with a valid calendar.json and reports its count", async () => {
+  const folder = await mkdtemp(join(tmpdir(), "kennel-calendar-"))
+  try {
+    await writeFile(
+      join(folder, "calendar.json"),
+      JSON.stringify({
+        events: [{ title: "Standup", start: "2026-09-10T09:00:00" }],
+      }),
+    )
+    const detection = await plugin.detect({ folder })
+    assert.equal(detection.status, "available")
+    assert.equal(detection.count, 1)
+  } finally {
+    await rm(folder, { recursive: true, force: true })
+  }
+})
+
+test("detect reports an error when a calendar.json exists but is invalid", async () => {
+  const folder = await mkdtemp(join(tmpdir(), "kennel-calendar-"))
+  try {
+    await writeFile(
+      join(folder, "calendar.json"),
+      JSON.stringify({ title: "No events here" }),
+    )
+    const detection = await plugin.detect({ folder })
+    assert.equal(detection.status, "error")
+    if (detection.status !== "error") return
+    assert.match(detection.error, /must be an array of events/)
+  } finally {
+    await rm(folder, { recursive: true, force: true })
+  }
+})
+
+test("handle returns in-band issues for a broken file while keeping valid events", async () => {
+  const folder = await mkdtemp(join(tmpdir(), "kennel-calendar-"))
+  try {
+    await writeFile(
+      join(folder, "calendar.json"),
+      JSON.stringify({
+        events: [
+          { title: "Good", start: "2026-09-10T09:00:00" },
+          { title: "Bad", start: "not-a-date" },
+        ],
+      }),
+    )
+    const result = await plugin.handle({ folder }, "")
+    assert.equal(result.kind, "available")
+    if (result.kind !== "available") return
+    assert.equal(result.data.status, "error")
+    assert.equal(result.data.issues.length, 1)
+    assert.equal(result.data.issues[0].path, "calendar.json: events[1].start")
+    // The whole file is flagged and excluded; no events render.
+    assert.equal(result.data.calendar.items.length, 0)
+  } finally {
+    await rm(folder, { recursive: true, force: true })
+  }
+})
+
+test("init scaffolds a valid calendar.json starter", async () => {
+  const folder = await mkdtemp(join(tmpdir(), "kennel-calendar-"))
+  try {
+    const result = await plugin.init({ folder })
+    assert.equal(result.files.length, 1)
+    assert.equal(result.files[0].path, "calendar.json")
+    // The CLI writes the returned content; simulate that write and confirm
+    // the starter immediately passes detection.
+    await writeFile(join(folder, "calendar.json"), result.files[0].content)
+    const detection = await plugin.detect({ folder })
+    assert.equal(detection.status, "available")
+    assert.equal(detection.count, 1)
+  } finally {
+    await rm(folder, { recursive: true, force: true })
+  }
+})

package/kernel/plugins/calendar/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@raggle-ai/tsconfig/base.json",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "jsx": "preserve",
+    "baseUrl": ".",
+    "allowImportingTsExtensions": true,
+    // local copy: bun doesn't read paths inherited via `extends`
+    "paths": {
+      "~/*": ["${configDir}/../../packages/*/src"]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "eslint.config.mjs"]
+}