kennel 0.2.13 → 0.2.16

package/kernel/packages/markdown/src/metadata.ts

@@ -1,63 +0,0 @@
-import { parseDocument } from "yaml";
-
-export type MarkdownMetadata = {
-  body: string;
-  entries: [string, unknown][];
-  lineOffset: number;
-  title?: string;
-};
-
-function frontmatter(content: string) {
-  const match = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/.exec(content);
-  if (!match) return undefined;
-
-  const parsed = parseDocument(match[1] ?? "");
-  const value = parsed.errors.length ? undefined : parsed.toJS();
-  const entries =
-    value && typeof value === "object" && !Array.isArray(value)
-      ? Object.entries(value)
-      : [];
-  const title = entries.find(([key]) => key === "title")?.[1];
-  return {
-    body: content.slice(match[0].length),
-    entries,
-    lineOffset: (match[0].match(/\n/g) ?? []).length,
-    title: typeof title === "string" && title.trim() ? title.trim() : undefined,
-  };
-}
-
-function inlineTitle(value: string) {
-  return value
-    .replaceAll(/[`*_~[\]]/g, "")
-    .replaceAll(/\s+/g, " ")
-    .trim();
-}
-
-function leadingHeading(content: string) {
-  const lines = content.replace(/^\uFEFF/, "").split(/\r?\n/);
-  let index = 0;
-  while (index < lines.length && !lines[index]?.trim()) index += 1;
-
-  const first = lines[index]?.trimEnd();
-  if (!first) return undefined;
-
-  const atx = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(first);
-  if (atx?.[2]) return inlineTitle(atx[2]);
-
-  const second = lines[index + 1]?.trim();
-  if (second && /^(=+|-+)$/.test(second)) return inlineTitle(first.trim());
-
-  return undefined;
-}
-
-/** Extract valid YAML frontmatter before rendering the Markdown body. */
-export function markdownMetadata(content: string): MarkdownMetadata {
-  const metadata = frontmatter(content);
-  const body = metadata?.body ?? content;
-  return {
-    body,
-    entries: metadata?.entries ?? [],
-    lineOffset: metadata?.lineOffset ?? 0,
-    title: metadata?.title ?? leadingHeading(body),
-  };
-}

package/kernel/packages/markdown/src/node.ts

@@ -1 +0,0 @@
-export * from "@raggle-ai/barkdown/node";

package/kernel/packages/markdown/styles.css

@@ -1 +0,0 @@
-@import "@raggle-ai/barkdown/styles.css";

package/kernel/packages/notes/SKILL.md

@@ -1,19 +0,0 @@
----
-name: kennel-notes-plugin
-description: Maintain the Kennel Notes folder-view plugin.
----
-
-# Kennel Notes plugin
-
-The Notes plugin owns the browser Notes tab UI and the notes-loading hook that
-keeps local Markdown notes separate from linked notes so the local list can
-render first.
-
-Unlike Calendar and Tasks, Notes does not use a single content file. The data
-comes from the Kennel metadata API, which scans Markdown files on the server and
-hydrates titles/open-path links. Keep that API-backed loading server-side; the
-client should only call the existing `/api/metadata?part=notes` endpoints and
-render the returned list.
-
-Keep the client entry browser-only. Do not import `./server` or `node:` modules
-from `src/client.tsx` or from modules that it imports.

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

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

package/kernel/packages/notes/package.json

@@ -1,73 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/package.json",
-  "name": "@raggle-ai/notes",
-  "version": "0.1.0",
-  "description": "Notes folder plugin: server-backed Markdown notes loading and React notes view for Kennel folders.",
-  "type": "module",
-  "license": "MIT",
-  "prettier": "@raggle-ai/prettier-config",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/raggle-ai/kennel.git",
-    "directory": "plugins/notes"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public"
-  },
-  "files": [
-    "src"
-  ],
-  "exports": {
-    ".": "./src/index.ts",
-    "./client": "./src/client.tsx",
-    "./data/use-folder-notes": "./src/data/use-folder-notes.ts",
-    "./manifest": "./src/manifest.ts",
-    "./parse": "./src/data/parse.ts",
-    "./pages/single-note-page": "./src/pages/single-note-page.tsx",
-    "./server": "./src/server.ts",
-    "./ui/folder-notes-list": "./src/ui/folder-notes-list.tsx"
-  },
-  "scripts": {
-    "test": "bun test test/*.test.mjs",
-    "typecheck": "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",
-    "lint": "eslint . --cache --cache-location .cache/.eslintcache",
-    "lint:fix": "eslint . --fix --cache --cache-location .cache/.eslintcache",
-    "clean": "git clean -xdf dist node_modules .cache .turbo/cache",
-    "pack:check": "npm pack --dry-run",
-    "publish:public:dry-run": "npm --@raggle-ai:registry=https://registry.npmjs.org publish --dry-run --access public --registry=https://registry.npmjs.org"
-  },
-  "dependencies": {
-    "kennel-plugins": "workspace:*",
-    "@raggle-ai/ui": "workspace:*",
-    "@tanstack/react-query": "catalog:tanstack",
-    "lucide-react": "^0.562.0"
-  },
-  "peerDependencies": {
-    "react": ">=18.3.0"
-  },
-  "devDependencies": {
-    "@eslint/compat": "catalog:eslint",
-    "@eslint/eslintrc": "catalog:eslint",
-    "@ianvs/prettier-plugin-sort-imports": "catalog:prettier",
-    "@prettier/plugin-oxc": "catalog:prettier",
-    "@raggle-ai/eslint-config": "workspace:*",
-    "@raggle-ai/prettier-config": "workspace:*",
-    "@raggle-ai/tsconfig": "workspace:*",
-    "@types/node": "catalog:",
-    "@types/react": "catalog:react19",
-    "@types/react-dom": "catalog:react19",
-    "eslint": "catalog:eslint",
-    "eslint-plugin-unused-imports": "catalog:eslint",
-    "prettier": "catalog:prettier",
-    "prettier-plugin-classnames": "catalog:prettier",
-    "prettier-plugin-merge": "catalog:prettier",
-    "prettier-plugin-tailwindcss": "catalog:prettier",
-    "react": "catalog:react19",
-    "react-dom": "catalog:react19",
-    "typescript": "catalog:",
-    "typescript-eslint": "catalog:eslint"
-  }
-}

package/kernel/packages/notes/src/client.tsx

@@ -1,11 +0,0 @@
-import type { FolderPluginClient } from "kennel-plugins/client"
-
-import { notesManifest } from "./manifest.ts"
-import { NotesPage } from "./pages/notes-page.tsx"
-
-export { NotesPage } from "./pages/notes-page.tsx"
-
-export const notesClient = {
-  ...notesManifest,
-  component: NotesPage,
-} satisfies FolderPluginClient

package/kernel/packages/notes/src/data/ai-input.ts

@@ -1,58 +0,0 @@
-import type { ComponentType } from "react"
-import { useEffect, useState } from "react"
-
-export type AiInputAdapter = {
-  Composer: ComponentType
-  install?: () => void | Promise<void>
-}
-
-const adapterPromises = new Map<string, Promise<AiInputAdapter>>()
-
-async function loadAiInput(folder?: string) {
-  const url = new URL("/api/config", window.location.origin)
-  if (folder) url.searchParams.set("path", folder)
-  const response = await fetch(url)
-  if (!response.ok) return null
-  const config = (await response.json()) as { aiInputModule?: unknown }
-  const moduleUrl = config.aiInputModule
-  if (typeof moduleUrl !== "string" || !moduleUrl) return null
-  const existing = adapterPromises.get(moduleUrl)
-  if (existing) return existing
-
-  const adapterPromise = import(/* @vite-ignore */ moduleUrl).then((module) => {
-    const adapter = module.default as AiInputAdapter | undefined
-    if (!adapter?.Composer) {
-      throw new Error(
-        "The AI input module must default-export an adapter with a Composer component.",
-      )
-    }
-    return adapter
-  })
-  adapterPromises.set(moduleUrl, adapterPromise)
-  return adapterPromise
-}
-
-export function useAiInput(folder?: string) {
-  const [loaded, setLoaded] = useState<{
-    folder?: string
-    adapter: AiInputAdapter | null
-  }>()
-
-  useEffect(() => {
-    let active = true
-    void loadAiInput(folder)
-      .then(async (value) => {
-        if (!active) return
-        await value?.install?.()
-        if (active) setLoaded({ folder, adapter: value })
-      })
-      .catch((error: unknown) => {
-        console.error("Could not load the configured AI input adapter.", error)
-      })
-    return () => {
-      active = false
-    }
-  }, [folder])
-
-  return loaded?.folder === folder ? (loaded?.adapter ?? null) : null
-}

package/kernel/packages/notes/src/data/api.ts

@@ -1,40 +0,0 @@
-import type { FolderFile } from "@raggle-ai/ui/lib/folder-activity"
-
-export type NotesScope = "local" | "linked"
-
-export type NotesMetadata = {
-  files: { items: FolderFile[] }
-  folder: string
-}
-
-export async function fetchMetadataPart(
-  href: string,
-  part: "notes",
-  options: {
-    signal?: AbortSignal
-    notesScope?: NotesScope
-    headers?: Record<string, string>
-  } = {},
-): Promise<NotesMetadata> {
-  const current = new URL(href, window.location.origin)
-  const url = new URL("/api/metadata", window.location.origin)
-  const route = current.pathname.split("/").filter(Boolean)
-  const encoded = route[0] === "folder" ? route[1] : undefined
-  const folder = current.searchParams.get("folder")
-  if (folder) url.searchParams.set("path", folder)
-  else if (encoded) {
-    const base64 = encoded.replaceAll("-", "+").replaceAll("_", "/")
-    const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=")
-    const binary = atob(padded)
-    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0))
-    url.searchParams.set("path", new TextDecoder().decode(bytes))
-  }
-  url.searchParams.set("part", part)
-  if (options.notesScope) url.searchParams.set("notesScope", options.notesScope)
-  const response = await fetch(url, {
-    headers: options.headers,
-    signal: options.signal,
-  })
-  if (!response.ok) throw new Error(await response.text())
-  return (await response.json()) as NotesMetadata
-}

package/kernel/packages/notes/src/data/parse.ts

@@ -1,15 +0,0 @@
-export type NotesFile = Record<string, unknown>
-export type NotesDataset = {
-  files: { items: NotesFile[] }
-  folder: string
-}
-
-export function parseNotesDataset(value: unknown): NotesDataset | undefined {
-  if (!value || typeof value !== "object") return undefined
-  const data = value as { files?: unknown; folder?: unknown }
-  const files = data.files as { items?: unknown } | undefined
-  if (typeof data.folder !== "string" || !Array.isArray(files?.items)) {
-    return undefined
-  }
-  return { files: { items: files.items as NotesFile[] }, folder: data.folder }
-}

package/kernel/packages/notes/src/data/routing.ts

@@ -1,33 +0,0 @@
-export function folderPathId(path: string) {
-  const bytes = new TextEncoder().encode(path)
-  let binary = ""
-  for (const byte of bytes) binary += String.fromCharCode(byte)
-  return btoa(binary)
-    .replaceAll("+", "-")
-    .replaceAll("/", "_")
-    .replaceAll("=", "")
-}
-
-export function parseViewerRoute(href: string) {
-  const url = new URL(href, window.location.origin)
-  const parts = url.pathname.split("/").filter(Boolean)
-  const folderIndex = parts.indexOf("folder")
-  const encoded = folderIndex >= 0 ? parts[folderIndex + 1] : undefined
-  let folder = url.searchParams.get("folder") ?? undefined
-  if (!folder && encoded) {
-    const base64 = encoded.replaceAll("-", "+").replaceAll("_", "/")
-    const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=")
-    const binary = atob(padded)
-    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0))
-    folder = new TextDecoder().decode(bytes)
-  }
-  return { folder }
-}
-
-export function folderSectionHref(folder: string, section: string) {
-  return `/folder/${folderPathId(folder)}/${section}`
-}
-
-export function folderDocumentHref(folder: string, document: string) {
-  return `/folder/${folderPathId(folder)}/document/${folderPathId(document)}`
-}

package/kernel/packages/notes/src/data/use-folder-notes.ts

@@ -1,49 +0,0 @@
-import { useMemo, useRef } from "react"
-import { useQuery } from "@tanstack/react-query"
-
-import { fetchMetadataPart } from "./api.ts"
-import { folderPathId, parseViewerRoute } from "./routing.ts"
-
-// Shared keys let the shell start requests before the lazy Notes page arrives.
-// Both observers reuse the same requests and keep sidebar counts in sync.
-export function useFolderNotes(href: string, enabled = true) {
-  const retryLinked = useRef(false)
-  const folder = parseViewerRoute(href).folder
-  const folderId = folder ? folderPathId(folder) : "none"
-  const options = (notesScope: "local" | "linked") => ({
-    enabled: enabled && Boolean(folder),
-    gcTime: 5 * 60_000,
-    queryFn: ({ signal }: { signal: AbortSignal }) => {
-      const retry = notesScope === "linked" && retryLinked.current
-      if (retry) retryLinked.current = false
-      return fetchMetadataPart(href, "notes", {
-        headers: retry ? { "x-kennel-retry-linked": "1" } : undefined,
-        notesScope,
-        signal,
-      })
-    },
-    queryKey: ["folder", folderId, "notes", notesScope],
-    staleTime: 15_000,
-  })
-  const local = useQuery(options("local"))
-  const linked = useQuery(options("linked"))
-  const files = useMemo(
-    () =>
-      local.data || linked.data
-        ? [
-            ...(local.data?.files.items ?? []),
-            ...(linked.data?.files.items ?? []),
-          ]
-        : undefined,
-    [local.data, linked.data],
-  )
-  return {
-    local,
-    linked,
-    files,
-    retryLinked: () => {
-      retryLinked.current = true
-      void linked.refetch()
-    },
-  }
-}

package/kernel/packages/notes/src/index.ts

@@ -1,2 +0,0 @@
-export { notesClient, NotesPage } from "./client.tsx"
-export { notesManifest } from "./manifest.ts"

package/kernel/packages/notes/src/manifest.ts

@@ -1,13 +0,0 @@
-import type { FolderPluginManifest } from "kennel-plugins"
-
-export const notesManifest = {
-  id: "notes",
-  icon: {
-    paths: [
-      "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8Z",
-      "M14 2v6h6",
-      "M8 13h8M8 17h6",
-    ],
-  },
-  label: "Notes",
-} satisfies FolderPluginManifest

package/kernel/packages/notes/src/pages/notes-page.tsx

@@ -1,112 +0,0 @@
-import type { ReactElement } from "react"
-import { useState } from "react"
-
-import type { FolderFile } from "@raggle-ai/ui/lib/folder-activity"
-import { FolderFilterBar } from "@raggle-ai/ui/components/folder-filter-bar"
-import { useFolderFilter } from "@raggle-ai/ui/hooks/use-folder-filter"
-
-import { useAiInput } from "../data/ai-input.ts"
-import {
-  folderDocumentHref,
-  folderPathId,
-  folderSectionHref,
-  parseViewerRoute,
-} from "../data/routing.ts"
-import { useFolderNotes } from "../data/use-folder-notes.ts"
-import {
-  AiComposerAction,
-  AiComposerControls,
-} from "../ui/ai-composer-controls.tsx"
-import { FolderNotesList } from "../ui/folder-notes-list.tsx"
-
-/** Folder that directly contains a note, including a note below the view root. */
-function noteFolder(file: FolderFile, viewedFolder?: string): string | null {
-  const root = file.folder ?? viewedFolder
-  if (!root) return null
-  const parent = file.relativePath
-    .replaceAll("\\", "/")
-    .split("/")
-    .slice(0, -1)
-    .filter(Boolean)
-    .join("/")
-  return parent ? `${root.replace(/[\\/]+$/, "")}/${parent}` : root
-}
-
-/** Folder Notes page: local and linked Markdown notes plus the AI composer. */
-export function NotesPage(): ReactElement {
-  const [composerOpen, setComposerOpen] = useState(false)
-  const href = window.location.href
-  const folder = parseViewerRoute(href).folder
-  const aiInput = useAiInput(folder)
-  const folderId = folder ? folderPathId(folder) : "none"
-  // Metadata events are handled once by the shared shell.
-  const { local: query, linked, files, retryLinked } = useFolderNotes(href)
-  const filter = useFolderFilter(files ?? [], {
-    allowOutside: true,
-    getFolder: (file) => noteFolder(file, folder),
-    rootFolder: folder ?? "",
-  })
-
-  return (
-    <>
-      <FolderNotesList
-        key={`${folderId}:${filter.effectiveSelected}`}
-        action={
-          aiInput ? (
-            <AiComposerAction
-              onOpenChange={setComposerOpen}
-              open={composerOpen}
-            />
-          ) : undefined
-        }
-        documentHref={(file) => {
-          const target = file.folder ?? folder
-          return target
-            ? folderDocumentHref(target, file.relativePath)
-            : file.relativePath
-        }}
-        error={query.error ? String(query.error) : ""}
-        files={filter.visibleItems}
-        filter={
-          filter.choices.length > 1 ? (
-            <FolderFilterBar
-              ariaLabel="Filter notes by folder"
-              choices={filter.choices}
-              onSelect={filter.setSelected}
-              selected={filter.effectiveSelected}
-              total={filter.total}
-            />
-          ) : undefined
-        }
-        folder={folder}
-        folderHref={(source) => folderSectionHref(source, "notes")}
-        loading={query.isLoading}
-      />
-      {query.error ? (
-        <button className="px-4" onClick={() => void query.refetch()}>
-          Retry local notes
-        </button>
-      ) : null}
-      {linked.isLoading ? (
-        <p role="status" className="text-muted-foreground px-4 text-sm">
-          Loading linked notes…
-        </p>
-      ) : null}
-      {linked.error ? (
-        <p role="alert" className="px-4 text-sm">
-          Linked notes could not load.{" "}
-          <button type="button" onClick={retryLinked}>
-            Retry
-          </button>
-        </p>
-      ) : null}
-      {aiInput ? (
-        <AiComposerControls
-          adapter={aiInput}
-          onOpenChange={setComposerOpen}
-          open={composerOpen}
-        />
-      ) : null}
-    </>
-  )
-}

package/kernel/packages/notes/src/pages/single-note-page.tsx

@@ -1,57 +0,0 @@
-import type { ComponentProps, ReactNode } from "react"
-
-import { FileRenderer } from "@raggle-ai/ui/components/file-renderer"
-
-/**
- * Shared page shell for an individual note. The host supplies document loading,
- * actions, and integrations; Notes composes the shared renderer and page states.
- */
-export function SingleNotePage({
-  renderer,
-  embedded = false,
-  error,
-  header,
-  live = false,
-  loading = false,
-  panel = false,
-  sessionHeader,
-  tray,
-}: {
-  renderer?: ComponentProps<typeof FileRenderer>
-  embedded?: boolean
-  error?: string
-  header: ReactNode
-  live?: boolean
-  loading?: boolean
-  panel?: boolean
-  sessionHeader?: ReactNode
-  tray?: ReactNode
-}) {
-  return (
-    <section
-      className="markdown-page"
-      data-embedded={embedded || panel ? "true" : undefined}
-      data-panel={panel ? "true" : undefined}
-    >
-      {header}
-      {sessionHeader}
-      {live ? (
-        <div className="pop-live" role="status">
-          <span aria-hidden="true">●</span> Live — refreshing on save
-        </div>
-      ) : null}
-      {error ? (
-        <p role="alert" className="p-6">
-          {error}
-        </p>
-      ) : renderer ? (
-        <FileRenderer {...renderer} />
-      ) : loading ? (
-        <p role="status" className="p-6">
-          Loading file…
-        </p>
-      ) : null}
-      {tray}
-    </section>
-  )
-}

package/kernel/packages/notes/src/server.ts

@@ -1,88 +0,0 @@
-import { readdir, stat } from "node:fs/promises"
-import { basename, extname, relative, resolve, sep } from "node:path"
-
-import type {
-  FolderPluginContext,
-  FolderPluginData,
-  FolderPluginDetection,
-  FolderPluginServer,
-} from "kennel-plugins/server"
-
-import { notesManifest } from "./manifest.ts"
-
-const markdownExtensions = new Set([".md", ".markdown"])
-
-async function listMarkdownFiles(folder: string) {
-  const files: Array<{
-    activityAt: number
-    folder?: string
-    name: string
-    relativePath: string
-  }> = []
-  const visit = async (current: string) => {
-    const entries = await readdir(current, { withFileTypes: true }).catch(
-      () => [],
-    )
-    for (const entry of entries) {
-      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue
-      const path = resolve(current, entry.name)
-      if (entry.isDirectory()) {
-        await visit(path)
-        continue
-      }
-      if (!entry.isFile() || !markdownExtensions.has(extname(entry.name))) {
-        continue
-      }
-      const details = await stat(path).catch(() => undefined)
-      files.push({
-        activityAt: details?.mtimeMs ?? 0,
-        name: basename(entry.name, extname(entry.name)),
-        relativePath: relative(folder, path).split(sep).join("/"),
-      })
-    }
-  }
-  await visit(folder)
-  return files.sort((left, right) => right.activityAt - left.activityAt)
-}
-
-async function loadNotes(folder: string, linkedFolders: string[] = []) {
-  const localFiles = await listMarkdownFiles(folder)
-  const linked = await Promise.all(
-    linkedFolders.map(async (linkedFolder) => ({
-      files: await listMarkdownFiles(linkedFolder),
-      folder: linkedFolder,
-    })),
-  )
-  return {
-    files: {
-      items: [
-        ...localFiles,
-        ...linked.flatMap((group) =>
-          group.files.map((file) => ({ ...file, folder: group.folder })),
-        ),
-      ],
-    },
-    folder,
-    status: "available",
-  }
-}
-
-export function createNotesPlugin(): FolderPluginServer {
-  return {
-    ...notesManifest,
-    async detect({
-      folder,
-    }: FolderPluginContext): Promise<FolderPluginDetection> {
-      const files = await listMarkdownFiles(folder)
-      return files.length > 0
-        ? { count: files.length, status: "available" }
-        : { status: "available" }
-    },
-    async handle({
-      folder,
-      linkedFolders,
-    }: FolderPluginContext): Promise<FolderPluginData> {
-      return { data: await loadNotes(folder, linkedFolders), kind: "available" }
-    },
-  }
-}