kennel 0.2.2 → 0.2.5

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

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

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

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

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

@@ -1,17 +0,0 @@
-{
-  "$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"]
-}