kennel 0.2.0 → 0.2.2

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

@@ -0,0 +1,134 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import { collectionRecords } from "../src/data/query.ts"
+import { recordOrder } from "../src/data/sort.ts"
+
+const record = (id, fields, modifiedAt = 0, title = id) => ({
+  id,
+  path: id,
+  relativePath: id,
+  title,
+  modifiedAt,
+  fields,
+  validationErrors: [],
+})
+
+const collection = (records, sort) => ({
+  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: [], ...(sort ? { sort } : {}) },
+  records,
+})
+
+const order = (records, sort) =>
+  [...records].sort(recordOrder(sort)).map((entry) => entry.id)
+
+test("omitted sort defaults to modifiedAt but defined empty sort uses only title/id tail", () => {
+  const source = [
+    record("z", {}, 2_000, "Zulu"),
+    record("a", {}, 1_000, "Alpha"),
+    record("b", {}, 3_000, "Beta"),
+  ]
+
+  assert.deepEqual(order(source), ["b", "z", "a"])
+  assert.deepEqual(order(source, []), ["a", "b", "z"])
+})
+
+test("custom sort dominates modifiedAt and uses title/id tail", () => {
+  const source = [
+    record("newer", { priority: "b" }, 2_000, "Zulu"),
+    record("older", { priority: "a" }, 1_000, "Zulu"),
+    record("tail-b", { priority: "a" }, 3_000, "Same"),
+    record("tail-a", { priority: "a" }, 4_000, "Same"),
+  ]
+
+  assert.deepEqual(order(source, [{ field: "priority", direction: "asc" }]), [
+    "tail-a",
+    "tail-b",
+    "older",
+    "newer",
+  ])
+})
+
+test("custom sort honors multiple keys in listed order", () => {
+  const source = [
+    record("sales-b", { status: "todo", team: "sales" }),
+    record("eng-a", { status: "todo", team: "eng" }),
+    record("done", { status: "done", team: "sales" }),
+    record("eng-b", { status: "todo", team: "eng" }),
+  ]
+
+  assert.deepEqual(
+    order(source, [
+      { field: "status", direction: "desc" },
+      { field: "team", direction: "asc" },
+    ]),
+    ["eng-a", "eng-b", "sales-b", "done"],
+  )
+})
+
+test("missing and null sort fields are last in either direction", () => {
+  const source = [
+    record("missing", {}),
+    record("null", { rank: null }),
+    record("a", { rank: "a" }),
+    record("b", { rank: "b" }),
+  ]
+
+  assert.deepEqual(order(source, [{ field: "rank", direction: "asc" }]), [
+    "a",
+    "b",
+    "missing",
+    "null",
+  ])
+  assert.deepEqual(order(source, [{ field: "rank", direction: "desc" }]), [
+    "b",
+    "a",
+    "missing",
+    "null",
+  ])
+})
+
+test("sort fields resolve through nested paths", () => {
+  const source = [
+    record("low", { priority: { level: 2 } }),
+    record("high", { priority: { level: 12 } }),
+  ]
+
+  assert.deepEqual(
+    order(source, [{ field: "priority.level", direction: "asc" }]),
+    ["low", "high"],
+  )
+})
+
+test("collectionRecords narrows by filter and query without re-sorting", () => {
+  const source = [
+    record("a", { status: "lead" }, 3_000, "Alpha"),
+    record("b", { status: "client" }, 1_000, "Beta"),
+    record("c", { status: "lead" }, 2_000, "Gamma"),
+  ]
+  const base = collection(source)
+  base.ui.filters = ["status"]
+
+  const indexed = [...source].sort(recordOrder())
+  assert.deepEqual(
+    collectionRecords({ ...base, records: indexed }, { status: "lead" }).map(
+      (entry) => entry.id,
+    ),
+    ["a", "c"],
+  )
+  assert.deepEqual(
+    collectionRecords({ ...base, records: indexed }, {}, "beta").map(
+      (entry) => entry.id,
+    ),
+    ["b"],
+  )
+})

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

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict"
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import test from "node:test"
+
+import { folderWorkspace } from "../src/data/workspace.ts"
+
+test("nested workspaces inherit schema declarations relative to their config owner", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "workspace-")))
+  try {
+    mkdirSync(join(root, "clients/acme"), { recursive: true })
+    mkdirSync(join(root, "schemas"))
+    writeFileSync(join(root, "schemas/client.json"), "{}")
+    writeFileSync(
+      join(root, "raggle.json"),
+      JSON.stringify({
+        title: "Company",
+        schemas: [{ path: "clients", schema: "schemas/client.json" }],
+      }),
+    )
+    writeFileSync(
+      join(root, "clients/acme/raggle.json"),
+      JSON.stringify({ title: "Acme" }),
+    )
+    const workspace = folderWorkspace(join(root, "clients/acme"))
+    assert.equal(workspace.root, root)
+    assert.equal(workspace.schemaPath, join(root, "schemas/client.json"))
+    assert.equal(workspace.config.title, "Acme")
+    assert.deepEqual(
+      workspace.breadcrumbs.map((item) => item.schema),
+      [false, true, true],
+    )
+    assert.deepEqual(
+      workspace.breadcrumbs.map((item) => item.path),
+      [root, join(root, "clients"), join(root, "clients/acme")],
+    )
+    assert.deepEqual(folderWorkspace(root).schemas, [
+      {
+        folder: join(root, "clients"),
+        schemaPath: join(root, "schemas/client.json"),
+      },
+    ])
+    writeFileSync(join(root, "clients/acme/_schema.json"), "{}")
+    assert.equal(
+      folderWorkspace(join(root, "clients/acme")).schemaPath,
+      join(root, "clients/acme/_schema.json"),
+    )
+    writeFileSync(join(root, "clients/acme/schema.json"), "{}")
+    assert.equal(
+      folderWorkspace(join(root, "clients/acme")).schemaPath,
+      join(root, "clients/acme/schema.json"),
+    )
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+test("schema mappings cannot escape the workspace, including through symlinks", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "workspace-")))
+  const outside = realpathSync(mkdtempSync(join(tmpdir(), "outside-")))
+  try {
+    mkdirSync(join(root, "clients"))
+    writeFileSync(join(outside, "schema.json"), "{}")
+    const configure = (schema) =>
+      writeFileSync(
+        join(root, "raggle.json"),
+        JSON.stringify({ schemas: [{ path: "clients", schema }] }),
+      )
+    configure(join(outside, "schema.json"))
+    assert.throws(() => folderWorkspace(root), /escapes/)
+    symlinkSync(outside, join(root, "linked"))
+    configure("linked/schema.json")
+    assert.throws(() => folderWorkspace(root), /escapes/)
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+    rmSync(outside, { recursive: true, force: true })
+  }
+})

package/kernel/packages/schemas/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"]
+}

package/kernel/packages/session-finding/package.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@raggle-ai/session-finding",
+  "version": "0.0.0",
+  "description": "Server-only read access to local coding-agent sessions for the Kennel viewer.",
+  "private": true,
+  "type": "module",
+  "prettier": "@raggle-ai/prettier-config",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "build": "tsc --noEmit",
+    "format": "prettier . --check --cache --cache-location .cache/.prettiercache --ignore-path ../../.prettierignore",
+    "format:fix": "prettier . --write --cache --cache-location .cache/.prettiercache --ignore-path ../../.prettierignore",
+    "test": "bun test test/*.test.mjs",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@raggle-ai/local": "0.14.0"
+  },
+  "devDependencies": {
+    "@ianvs/prettier-plugin-sort-imports": "catalog:prettier",
+    "@raggle-ai/prettier-config": "workspace:*",
+    "@raggle-ai/tsconfig": "workspace:*",
+    "@types/node": "catalog:",
+    "prettier": "catalog:prettier",
+    "prettier-plugin-classnames": "catalog:prettier",
+    "prettier-plugin-merge": "catalog:prettier",
+    "prettier-plugin-tailwindcss": "catalog:prettier",
+    "typescript": "catalog:"
+  }
+}

package/kernel/packages/session-finding/src/index.ts

@@ -0,0 +1,120 @@
+import type { AiChatApplicationSchema } from "@raggle-ai/local"
+import type {
+  LocalSession,
+  LocalSessionSummary,
+} from "@raggle-ai/local/sessions"
+import {
+  loadApplicationSchemas,
+  resolveApplicationOpenTarget,
+} from "@raggle-ai/local"
+import {
+  listLocalSessions,
+  readLocalSession,
+  sessionResumeCommand,
+} from "@raggle-ai/local/sessions"
+
+const sessionClients = ["claude", "codex", "cursor", "opencode"] as const
+
+export type FolderSession = LocalSessionSummary & {
+  href?: string
+  resumeCommand?: string
+}
+
+export type SessionTranscript = LocalSession
+
+type SessionApplication = AiChatApplicationSchema
+type ResumeDeeplink = NonNullable<SessionApplication["deeplinks"]>[number]
+type RadarTarget = (
+  application: SessionApplication,
+  options: { worktree: string },
+  session: { sessionId: string; worktree: string },
+) => { type: "deeplink"; value: string } | undefined
+
+export type SessionFindingDeps = {
+  listSessions: (options: {
+    folder: string
+    limit: number
+  }) => Promise<LocalSessionSummary[]>
+  loadSchemas: () => SessionApplication[]
+  readTranscript: (sessionId: string) => Promise<LocalSession>
+  resumeCommand: (session: LocalSessionSummary) => string | undefined
+  radarTarget: RadarTarget
+}
+
+function decorate(
+  session: LocalSessionSummary,
+  applications: SessionApplication[],
+  resumeCommand: SessionFindingDeps["resumeCommand"],
+  radarTarget: RadarTarget,
+): FolderSession {
+  const command = resumeCommand(session)
+  const application = applications.find(
+    (candidate) => candidate.slug === session.client,
+  )
+  if (!application)
+    return command ? { ...session, resumeCommand: command } : session
+  const separator = session.id.indexOf(":")
+  const sessionId = session.id.slice(separator + 1)
+  if (separator < 1 || !sessionId) return session
+  const target = radarTarget(
+    application,
+    { worktree: session.folder },
+    { sessionId, worktree: session.folder },
+  )
+  if (target?.type !== "deeplink")
+    return command ? { ...session, resumeCommand: command } : session
+  return { ...session, href: target.value, resumeCommand: command }
+}
+
+const deps: SessionFindingDeps = {
+  listSessions: (options) => listLocalSessions(options),
+  loadSchemas: () =>
+    loadApplicationSchemas().filter((application) =>
+      sessionClients.includes(
+        application.slug as (typeof sessionClients)[number],
+      ),
+    ),
+  readTranscript: readLocalSession,
+  resumeCommand: sessionResumeCommand,
+  radarTarget: (application, options, session) => {
+    const target = resolveApplicationOpenTarget(
+      {
+        ...application,
+        deeplinks: application.deeplinks?.filter(
+          (deeplink: ResumeDeeplink) => deeplink.intent === "resume-session",
+        ),
+        launchers: undefined,
+      },
+      options,
+      session,
+    )
+    return target?.type === "deeplink"
+      ? { type: "deeplink", value: target.value }
+      : undefined
+  },
+}
+
+export function createSessionFinding(deps: SessionFindingDeps) {
+  async function listFolderSessions(options: {
+    folder: string
+    limit: number
+  }) {
+    const sessions = await deps.listSessions({
+      folder: options.folder,
+      limit: options.limit,
+    })
+    const applications = deps.loadSchemas()
+    return {
+      items: sessions.map((session) =>
+        decorate(session, applications, deps.resumeCommand, deps.radarTarget),
+      ),
+    }
+  }
+  async function readSessionTranscript(sessionId: string) {
+    return deps.readTranscript(sessionId)
+  }
+  return { listFolderSessions, readSessionTranscript }
+}
+
+export const { listFolderSessions, readSessionTranscript } =
+  createSessionFinding(deps)

package/kernel/packages/session-finding/test/list-sessions.test.mjs

@@ -0,0 +1,139 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import { createSessionFinding } from "../src/index.ts"
+
+const session = {
+  archived: false,
+  client: "opencode",
+  createdAt: "2026-01-01T00:00:00.000Z",
+  folder: "/tmp/project",
+  id: "opencode:ses_abc123",
+  lastMessageAt: "2026-01-02T00:00:00.000Z",
+  messageCount: 4,
+  title: "Extract sessions",
+}
+
+function application(overrides = {}) {
+  return {
+    name: "OpenCode",
+    slug: "opencode",
+    category: "Application",
+    homepage: "https://opencode.ai",
+    platforms: ["macos", "linux", "windows"],
+    capabilities: {
+      opensProjectFolder: true,
+      canResumeProjectSession: true,
+      canStartNewProjectSession: true,
+    },
+    deeplinks: [
+      {
+        id: "resume-session",
+        label: "Resume OpenCode session",
+        intent: "resume-session",
+        urlTemplate:
+          "opencode://open-project?directory={absolutePath}&session={sessionId}",
+        variables: [],
+      },
+      {
+        id: "open-folder",
+        label: "Open folder",
+        intent: "open-project",
+        urlTemplate: "opencode://open-project?directory={absolutePath}",
+        variables: [],
+      },
+    ],
+    launchers: [
+      {
+        id: "open",
+        label: "Open",
+        intent: "open-project",
+        urlTemplate: "opencode {worktree}",
+        variables: [],
+        kind: "command",
+      },
+    ],
+    ...overrides,
+  }
+}
+
+function deps(overrides = {}) {
+  return {
+    listSessions: async ({ folder, limit }) => [{ ...session, folder }],
+    loadSchemas: () => [application()],
+    readTranscript: async (sessionId) => ({ ...session, messages: [] }),
+    resumeCommand: () => "open 'codex://threads/abc'",
+    radarTarget: () => ({ type: "deeplink", value: "opencode://open-project" }),
+    ...overrides,
+  }
+}
+
+test("a supported app with a valid resume deep link gets an href and resume command", async () => {
+  const { listFolderSessions } = createSessionFinding(deps())
+  const result = await listFolderSessions({ folder: "/tmp/project", limit: 10 })
+  assert.equal(result.items.length, 1)
+  assert.equal(result.items[0].href, "opencode://open-project")
+  assert.equal(result.items[0].resumeCommand, "open 'codex://threads/abc'")
+})
+
+test("a supported app without a matching deep link keeps the session without an href", async () => {
+  const { listFolderSessions } = createSessionFinding(
+    deps({ radarTarget: () => undefined }),
+  )
+  const result = await listFolderSessions({ folder: "/tmp/project", limit: 10 })
+  assert.equal(result.items[0].href, undefined)
+  assert.equal(result.items[0].resumeCommand, "open 'codex://threads/abc'")
+})
+
+test("an unknown app keeps the original session without an href", async () => {
+  const { listFolderSessions } = createSessionFinding(
+    deps({ loadSchemas: () => [] }),
+  )
+  const result = await listFolderSessions({ folder: "/tmp/project", limit: 10 })
+  assert.deepEqual(result.items[0], {
+    ...session,
+    resumeCommand: "open 'codex://threads/abc'",
+  })
+})
+
+test("an invalid prefixed session id keeps the session without decoration", async () => {
+  const finding = createSessionFinding(
+    deps({
+      listSessions: async () => [{ ...session, id: "not-prefixed" }],
+    }),
+  )
+  const result = await finding.listFolderSessions({
+    folder: "/tmp/project",
+    limit: 10,
+  })
+  assert.deepEqual(result.items[0], { ...session, id: "not-prefixed" })
+})
+
+test("a missing resume command leaves the field absent", async () => {
+  const { listFolderSessions } = createSessionFinding(
+    deps({ resumeCommand: () => undefined }),
+  )
+  const result = await listFolderSessions({ folder: "/tmp/project", limit: 10 })
+  assert.equal(result.items[0].href, "opencode://open-project")
+  assert.equal(result.items[0].resumeCommand, undefined)
+})
+
+test("the requested folder and limit are forwarded to the session list", async () => {
+  const received = []
+  const { listFolderSessions } = createSessionFinding(
+    deps({
+      listSessions: async (options) => {
+        received.push(options)
+        return []
+      },
+    }),
+  )
+  await listFolderSessions({ folder: "/tmp/other", limit: 100 })
+  assert.deepEqual(received, [{ folder: "/tmp/other", limit: 100 }])
+})
+
+test("readSessionTranscript returns the transcript from the reader", async () => {
+  const { readSessionTranscript } = createSessionFinding(deps())
+  const transcript = await readSessionTranscript("opencode:ses_abc123")
+  assert.deepEqual(transcript, { ...session, messages: [] })
+})

package/kernel/packages/session-finding/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@raggle-ai/tsconfig/base.json",
+  "include": ["src/**/*.ts"],
+  "compilerOptions": {
+    "types": ["node"],
+    // local copy: bun doesn't read paths inherited via `extends`
+    "paths": {
+      "~/*": ["${configDir}/../../packages/*/src"]
+    }
+  }
+}

package/kernel/packages/ui/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Raggle AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/kernel/packages/ui/components.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "../../tooling/tailwind/globals.css",
+    "baseColor": "neutral",
+    "cssVariables": true
+  },
+  "iconLibrary": "lucide",
+  "aliases": {
+    "components": "@raggle-ai/ui/components",
+    "ui": "@raggle-ai/ui/components",
+    "utils": "@raggle-ai/ui/lib/utils",
+    "lib": "@raggle-ai/ui/lib",
+    "hooks": "@raggle-ai/ui/hooks"
+  }
+}

package/kernel/packages/ui/eslint.config.js

@@ -0,0 +1,8 @@
+import baseConfig from "@raggle-ai/eslint-config/base"
+
+export default [
+  ...baseConfig,
+  {
+    ignores: ["dist/**", "**/_generated/", "vendor/**"],
+  },
+]