kennel 0.2.13 → 0.2.15

package/kernel/packages/api-client/src/index.ts

@@ -1,206 +0,0 @@
-import createClient from "openapi-fetch";
-import type { z } from "zod";
-import type { paths } from "./generated";
-import {
-  documentEditSchema,
-  metadataSchemas,
-  routes,
-} from "../../api/src/contracts/schemas";
-import type {
-  DocumentEditInput,
-  FolderEntitiesSearch,
-  MetadataPart,
-  MetadataResponse,
-} from "../../api/src/contracts";
-import { parseViewerRoute } from "../../api/src/shared/viewer-route";
-import { expectedError } from "./errors";
-export { ApiClientError, expectedError } from "./errors";
-export { documentResponse, projectSearchResponse } from "./responses";
-export type * from "../../api/src/contracts";
-export type { paths, operations } from "./generated";
-
-export type Fetch = (
-  input: RequestInfo | URL,
-  init?: RequestInit,
-) => Promise<Response>;
-export type RequestOptions = { signal?: AbortSignal };
-export type MetadataOptions = RequestOptions & { headers?: Record<string, string> } &
-  Omit<z.input<typeof routes.metadata.query>, "path" | "part">;
-
-/** One transport for browser, CLI and integration tests. Never captures global fetch. */
-export function createKennelClient(
-  options: { baseUrl?: string; fetch?: Fetch } = {},
-) {
-  const baseUrl =
-    options.baseUrl ??
-    (typeof window === "undefined"
-      ? "http://localhost"
-      : window.location.origin);
-  const transport = createClient<paths>({
-    baseUrl,
-    fetch: (request) => (options.fetch ?? globalThis.fetch)(request),
-  });
-  transport.use({
-    async onResponse({ response }) {
-      if (!response.ok) throw await expectedError(response);
-      if (
-        response.status !== 204 &&
-        !response.headers.get("content-type")?.includes("application/json")
-      )
-        throw new Error("The server returned a non-JSON response.");
-      return response;
-    },
-  });
-  async function decoded<S extends z.ZodType>(
-    schema: S,
-    pending: Promise<{ data?: unknown }>,
-  ): Promise<z.output<S>> {
-    return schema.parse((await pending).data);
-  }
-  const folder = (href: string) => {
-    const path = parseViewerRoute(href).folder;
-    return path?.startsWith("/") ? path : undefined;
-  };
-  const metadata = async <P extends MetadataPart>(
-    href: string,
-    part: P,
-    input: MetadataOptions = {},
-  ): Promise<MetadataResponse<P>> => {
-    const { signal, headers, ...query } = input;
-    const result = await transport.GET(routes.metadata.path, {
-      params: { query: { path: folder(href), part, ...query } },
-      signal,
-      headers,
-    });
-    // The selector, not a caller-chosen generic, determines the response contract.
-    return metadataSchemas[part].parse(result.data) as MetadataResponse<P>;
-  };
-  return {
-    metadata,
-    notes: (
-      input: {
-        path: string;
-        notesScope?: MetadataOptions["notesScope"];
-      } & RequestOptions,
-    ) =>
-      metadata(`/?folder=${encodeURIComponent(input.path)}`, "notes", {
-        notesScope: input.notesScope,
-        signal: input.signal,
-      }),
-    health: (input: RequestOptions = {}) =>
-      decoded(routes.health.response, transport.GET(routes.health.path, input)),
-    capabilities: (input: RequestOptions = {}) =>
-      decoded(
-        routes.capabilities.response,
-        transport.GET(routes.capabilities.path, input),
-      ),
-    config: (path?: string, input: RequestOptions = {}) =>
-      decoded(
-        routes.config.response,
-        transport.GET(routes.config.path, {
-          params: { query: { path } },
-          ...input,
-        }),
-      ),
-    document: (href: string, file: string, input: RequestOptions = {}) =>
-      decoded(
-        routes.document.response,
-        transport.GET(routes.document.path, {
-          params: { query: { path: folder(href), file } },
-          ...input,
-        }),
-      ),
-    documents: (href: string, input: RequestOptions = {}) =>
-      decoded(
-        routes.documents.response,
-        transport.GET(routes.documents.path, {
-          params: { query: { path: folder(href) } },
-          ...input,
-        }),
-      ),
-    projectSearch: (q: string, input: RequestOptions = {}) =>
-      decoded(
-        routes.projectSearch.response,
-        transport.GET(routes.projectSearch.path, {
-          params: { query: { q } },
-          ...input,
-        }),
-      ),
-    entities: (query: FolderEntitiesSearch = {}, input: RequestOptions = {}) =>
-      decoded(
-        routes.entities.response,
-        transport.GET(routes.entities.path, { params: { query }, ...input }),
-      ),
-    async documentEdit(body: DocumentEditInput, input: RequestOptions = {}) {
-      await decoded(
-        routes.documentEdit.response,
-        transport.POST(routes.documentEdit.path, {
-          body: documentEditSchema.parse(body),
-          ...input,
-        }),
-      );
-    },
-    async openPath(path: string, input: RequestOptions = {}) {
-      await transport.GET(routes.openPath.path, {
-        params: { query: { path } },
-        ...input,
-        parseAs: "text",
-      });
-    },
-    async openFolder(path: string, input: RequestOptions = {}) {
-      await transport.POST(routes.openFolder.path, {
-        params: { query: { path } },
-        ...input,
-        parseAs: "text",
-      });
-    },
-    async createAgentFile(folder: string, input: RequestOptions = {}) {
-      return decoded(
-        routes.createAgentFile.response,
-        transport.POST(routes.createAgentFile.path, {
-          params: { query: { path: folder } },
-          ...input,
-        }),
-      );
-    },
-    // Binary and extension-defined payloads deliberately do not pretend to be typed JSON.
-    async raw(path: string, file: string, input: RequestOptions = {}) {
-      const url = new URL("/api/raw", baseUrl);
-      url.search = new URLSearchParams({ path, file }).toString();
-      const response = await (options.fetch ?? globalThis.fetch)(url, input);
-      if (!response.ok) throw await expectedError(response);
-      return response;
-    },
-    async plugin(
-      id: string,
-      path: string,
-      subpath = "",
-      init?: RequestInit,
-    ): Promise<unknown> {
-      const url = new URL(`/api/plugins/${encodeURIComponent(id)}`, baseUrl);
-      url.search = new URLSearchParams({
-        path,
-        ...(subpath ? { subpath } : {}),
-      }).toString();
-      const response = await (options.fetch ?? globalThis.fetch)(url, init);
-      if (!response.ok) throw await expectedError(response);
-      return response.json();
-    },
-  };
-}
-
-/** Shared browser instance; Node callers should create a client with an explicit baseUrl. */
-export const api = createKennelClient();
-
-/**
- * Host action: open a physical file in the operating system's default app
- * through the shared browser client. Failed requests surface a stable,
- * user-friendly message instead of server internals.
- */
-export async function openPath(path: string, input: RequestOptions = {}) {
-  try {
-    await api.openPath(path, input);
-  } catch {
-    throw new Error("Could not open the default app.");
-  }
-}

package/kernel/packages/api-client/src/responses.ts

@@ -1,19 +0,0 @@
-import type { z } from "zod";
-import { routes } from "../../api/src/contracts/schemas";
-import { expectedError } from "./errors";
-
-async function read<S extends z.ZodType>(
-  schema: S,
-  response: Response,
-): Promise<z.output<S>> {
-  if (!response.ok) throw await expectedError(response);
-  if (!response.headers.get("content-type")?.includes("application/json"))
-    throw new Error("The server returned a non-JSON response.");
-  return schema.parse(await response.json());
-}
-
-// Compatibility for callers which already hold a Response; no unchecked casts.
-export const documentResponse = (response: Response) =>
-  read(routes.document.response, response);
-export const projectSearchResponse = (response: Response) =>
-  read(routes.projectSearch.response, response);

package/kernel/packages/api-client/test/client.test.ts

@@ -1,143 +0,0 @@
-import { expect, test } from "bun:test";
-import { createKennelClient, type MetadataResponse } from "../src";
-import { sendContract } from "../../api/src/server/contracts";
-import { createServer } from "node:http";
-
-const baseUrl = "http://127.0.0.1:5181";
-test("notes encode paths, infer payloads and forward cancellation", async () => {
-  let captured: Request | undefined;
-  const controller = new AbortController();
-  const client = createKennelClient({
-    baseUrl,
-    fetch: async (input) => {
-      captured = input as Request;
-      return Response.json({ folder: "/notes & café", files: { items: [] } });
-    },
-  });
-  const notes: MetadataResponse<"notes"> = await client.notes({
-    path: "/notes & café",
-    notesScope: "local",
-    signal: controller.signal,
-  });
-  expect(notes.files.items).toEqual([]);
-  expect(new URL(captured!.url).searchParams.get("path")).toBe("/notes & café");
-  expect(new URL(captured!.url).searchParams.get("notesScope")).toBe("local");
-  controller.abort();
-  expect(captured!.signal.aborted).toBe(true);
-});
-
-test("response shape mismatches fail instead of being asserted to a type", async () => {
-  const client = createKennelClient({
-    baseUrl,
-    fetch: async () =>
-      Response.json({
-        folder: "/notes",
-        files: { items: [{ name: "Missing required fields" }] },
-      }),
-  });
-  await expect(client.notes({ path: "/notes" })).rejects.toThrow();
-});
-
-test("selector determines validation even when another metadata shape is valid", async () => {
-  const client = createKennelClient({
-    baseUrl,
-    fetch: async () => Response.json({ folder: "/notes", assets: {} }),
-  });
-  await expect(client.metadata("/?folder=/notes", "notes")).rejects.toThrow();
-});
-
-test("structured errors and non-JSON responses are not mistaken for data", async () => {
-  const denied = createKennelClient({
-    baseUrl,
-    fetch: async () =>
-      Response.json(
-        { error: { code: "forbidden", message: "Denied" } },
-        { status: 403 },
-      ),
-  });
-  await expect(denied.health()).rejects.toMatchObject({
-    status: 403,
-    code: "forbidden",
-    message: "Denied",
-  });
-  const html = createKennelClient({
-    baseUrl,
-    fetch: async () => new Response("<html>fallback</html>"),
-  });
-  await expect(html.health()).rejects.toThrow("non-JSON");
-});
-
-test("document edit validates inputs before transport and validates success", async () => {
-  let requests = 0;
-  const client = createKennelClient({
-    baseUrl,
-    fetch: async (input) => {
-      requests++;
-      const request = input as Request;
-      expect(request.method).toBe("POST");
-      expect((await request.json()).replacement).toBe("new");
-      return Response.json({ saved: true });
-    },
-  });
-  const input = {
-    folder: "/notes",
-    path: "a.md",
-    original: "old",
-    start: 0,
-    end: 3,
-    replacement: "new",
-  };
-  await expect(client.documentEdit({ ...input, start: -1 })).rejects.toThrow();
-  expect(requests).toBe(0);
-  await client.documentEdit(input);
-  expect(requests).toBe(1);
-});
-
-test("server rejects contract violations before sending success headers", async () => {
-  const server = createServer((_request, response) =>
-    sendContract(response, new URL("/api/health", baseUrl), { viewer: 123 }),
-  );
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-  try {
-    const address = server.address();
-    if (!address || typeof address === "string")
-      throw new Error("Missing listener");
-    const response = await fetch(`http://127.0.0.1:${address.port}`);
-    expect(response.status).toBe(500);
-    expect(await response.json()).toEqual({
-      error: {
-        code: "invalid_response",
-        message: "Server response violated the API contract",
-      },
-    });
-  } finally {
-    await new Promise<void>((resolve, reject) =>
-      server.close((error) => (error ? reject(error) : resolve())),
-    );
-  }
-});
-
-// These checks run under tsc, never make network requests, and must stay rejected.
-function typeChecks(client: ReturnType<typeof createKennelClient>) {
-  // @ts-expect-error callers cannot specify an arbitrary metadata response type
-  client.metadata<{ invented: boolean }>("/", "notes");
-  // @ts-expect-error invalid scope
-  client.notes({ path: "/notes", notesScope: "everything" });
-  // @ts-expect-error edit requires replacement
-  client.documentEdit({
-    folder: "/notes",
-    path: "a.md",
-    original: "",
-    start: 0,
-    end: 0,
-  });
-  client.metadata("/", "notes").then((result) => {
-    // @ts-expect-error notes are not a workspace response
-    result.workspace;
-  });
-}
-void typeChecks;
-
-// The CLI's build-time declaration must stay compatible with the bundled factory.
-const cliFactory: typeof import("../../../cli/src/core/api-client").createKennelClient = createKennelClient;
-void cliFactory;

package/kernel/packages/api-client/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022", "module": "ESNext", "moduleResolution": "Bundler",
-    "strict": true, "skipLibCheck": true, "noEmit": true,
-    "allowImportingTsExtensions": true, "esModuleInterop": true,
-    "types": ["bun"], "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "paths": {
-      "~/*": ["${configDir}/../../packages/*/src"]
-    }
-  },
-  "include": ["src", "scripts", "test"]
-}

package/kernel/packages/kinds/package.json

@@ -1,24 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/package.json",
-  "name": "@raggle-ai/kennel-kinds",
-  "version": "0.0.0",
-  "description": "Leaf kind table shared by the Kennel API and the preview package.",
-  "type": "module",
-  "license": "MIT",
-  "private": true,
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/raggle-ai/kennel.git",
-    "directory": "packages/kinds"
-  },
-  "files": [
-    "src"
-  ],
-  "exports": {
-    ".": "./src/kinds.ts"
-  },
-  "devDependencies": {
-    "@types/node": "catalog:",
-    "typescript": "catalog:"
-  }
-}

package/kernel/packages/kinds/src/kinds.ts

@@ -1,172 +0,0 @@
-/**
- * Preview kinds for the Kennel pop-up viewer.
- *
- * One table for every server: the static viewer, the Vite hot viewer
- * (apps/web/server/preview-kinds.ts re-exports this file), and the core API.
- * Text kinds are delivered as UTF-8 `content` through
- * `/api/document`; non-text kinds (images, binary) are delivered through
- * `/api/raw` and referenced by the `rawUrl` field in the document response.
- */
-
-export type PreviewKind =
-  "binary" | "code" | "eml" | "html" | "image" | "markdown" | "table" | "text";
-
-export const previewTextKinds = new Set<PreviewKind>([
-  "code",
-  "eml",
-  "html",
-  "markdown",
-  "table",
-  "text",
-]);
-
-export function previewTextKind(kind: PreviewKind): boolean {
-  return previewTextKinds.has(kind);
-}
-
-const codeExtensions = new Set([
-  ".astro",
-  ".bash",
-  ".c",
-  ".cc",
-  ".cpp",
-  ".cs",
-  ".css",
-  ".dart",
-  ".ex",
-  ".exs",
-  ".go",
-  ".graphql",
-  ".h",
-  ".hpp",
-  ".hs",
-  ".java",
-  ".js",
-  ".jsx",
-  ".json",
-  ".kt",
-  ".less",
-  ".lua",
-  ".ml",
-  ".mjs",
-  ".php",
-  ".proto",
-  ".py",
-  ".rb",
-  ".rs",
-  ".scss",
-  ".sh",
-  ".sql",
-  ".svelte",
-  ".swift",
-  ".toml",
-  ".ts",
-  ".tsx",
-  ".vue",
-  ".xml",
-  ".yaml",
-  ".yml",
-  ".zsh",
-]);
-
-const imageExtensions = new Set([
-  ".avif",
-  ".bmp",
-  ".gif",
-  ".ico",
-  ".jpeg",
-  ".jpg",
-  ".png",
-  ".svg",
-  ".webp",
-]);
-
-const knownExtensions = new Set([
-  ...codeExtensions,
-  ...imageExtensions,
-  ".csv",
-  ".eml",
-  ".htm",
-  ".html",
-  ".markdown",
-  ".md",
-  ".mdx",
-  ".pdf",
-  ".text",
-  ".tsv",
-  ".txt",
-]);
-
-export function previewKind(path: string): PreviewKind | undefined {
-  const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
-  if (extension === ".htm" || extension === ".html") return "html";
-  if (extension === ".md" || extension === ".markdown" || extension === ".mdx")
-    return "markdown";
-  if (extension === ".text" || extension === ".txt") return "text";
-  if (extension === ".eml") return "eml";
-  if (extension === ".csv" || extension === ".tsv") return "table";
-  if (imageExtensions.has(extension)) return "image";
-  if (codeExtensions.has(extension)) return "code";
-  if (knownExtensions.has(extension)) return "binary";
-  return undefined;
-}
-
-const rawMime: Record<string, string> = {
-  ".avif": "image/avif",
-  ".bmp": "image/bmp",
-  ".gif": "image/gif",
-  ".htm": "text/html; charset=utf-8",
-  ".html": "text/html; charset=utf-8",
-  ".ico": "image/x-icon",
-  ".jpeg": "image/jpeg",
-  ".jpg": "image/jpeg",
-  ".pdf": "application/pdf",
-  ".png": "image/png",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-};
-
-export function previewRawMime(path: string): string | undefined {
-  const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
-  const mime = rawMime[extension];
-  if (mime) return mime;
-  if (previewKind(path) === "code" || previewKind(path) === "table")
-    return "text/plain; charset=utf-8";
-  return undefined;
-}
-
-/**
- * Media types servable through `/api/media` for inline `<video>`, `<audio>`,
- * and `<img>` sources referenced by documents. Deliberately separate from
- * `rawMime`: document previews decide kind through `previewKind`, while media
- * sources just need a safe Content-Type. No HTML/SVG here — active content
- * must never be served inline as media.
- */
-const mediaMime: Record<string, string> = {
-  ".aac": "audio/aac",
-  ".avif": "image/avif",
-  ".bmp": "image/bmp",
-  ".flac": "audio/flac",
-  ".gif": "image/gif",
-  ".ico": "image/x-icon",
-  ".jpeg": "image/jpeg",
-  ".jpg": "image/jpeg",
-  ".m4a": "audio/mp4",
-  ".m4v": "video/mp4",
-  ".mov": "video/quicktime",
-  ".mp3": "audio/mpeg",
-  ".mp4": "video/mp4",
-  ".oga": "audio/ogg",
-  ".ogg": "audio/ogg",
-  ".ogv": "video/ogg",
-  ".opus": "audio/opus",
-  ".png": "image/png",
-  ".wav": "audio/wav",
-  ".webm": "video/webm",
-  ".webp": "image/webp",
-};
-
-export function mediaRawMime(path: string): string | undefined {
-  const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
-  return mediaMime[extension];
-}

package/kernel/packages/markdown/README.md

@@ -1,40 +0,0 @@
-# @raggle-ai/markdown
-
-Internal BarackDown re-export consumed by every Kennel package that renders
-Markdown (`packages/ui`, `packages/api`, external plugins, `cli`, and
-`apps/web`). The
-purpose of this tiny package is to be the single place where Kennel decides
-which BarkDown implementation it uses.
-
-## Swapping between published and local BarkDown
-
-All Kennel packages import `@raggle-ai/markdown` (`workspace:*`), and this
-package's only dependency is `@raggle-ai/barkdown`. Edit that one line here,
-run `bun install` at the repo root, and the whole workspace follows.
-
-### Published npm version (default)
-
-```json
-"dependencies": {
-  "@raggle-ai/barkdown": "0.4.0"
-}
-```
-
-### Local barkdown git checkout
-
-```json
-"dependencies": {
-  "@raggle-ai/barkdown": "file:../../../barkdown/packages/barkdown"
-}
-```
-
-The relative path starts from `packages/markdown/` up to the sibling of this
-repository. Note that Bun copies `file:` dependencies at install time, so
-after changing anything in the barkdown repo (`pnpm build` there), run
-`bun install` again in the kennel root to refresh the copied build.
-
-Original file paths (`@raggle-ai/barkdown`, `@raggle-ai/barkdown/explorer`,
-…) are re-exported one-to-one, including the two CSS entry points, so
-consumer imports only change from `@raggle-ai/barkdown` to
-`@raggle-ai/markdown`. The root export also provides `markdownMetadata` to
-parse and strip YAML frontmatter before rendering Markdown.

package/kernel/packages/markdown/explorer.css

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

package/kernel/packages/markdown/package.json

@@ -1,30 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/package.json",
-  "name": "@raggle-ai/markdown",
-  "version": "0.1.0",
-  "description": "Internal BarkDown re-export used by Kennel packages. Swap @raggle-ai/barkdown between the published npm version and the local git checkout by editing the single dependency below (see README.md).",
-  "license": "MIT",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/raggle-ai/kennel.git",
-    "directory": "packages/markdown"
-  },
-  "files": [
-    "src",
-    "styles.css",
-    "explorer.css"
-  ],
-  "exports": {
-    ".": "./src/index.ts",
-    "./documents": "./src/documents.ts",
-    "./explorer": "./src/explorer.ts",
-    "./node": "./src/node.ts",
-    "./styles.css": "./styles.css",
-    "./explorer.css": "./explorer.css"
-  },
-  "dependencies": {
-    "@raggle-ai/barkdown": "0.6.1",
-    "yaml": "^2.9.0"
-  }
-}

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

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

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

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

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

@@ -1,2 +0,0 @@
-export * from "@raggle-ai/barkdown";
-export { markdownMetadata, type MarkdownMetadata } from "./metadata.ts";