blume 1.7.3 → 2.0.1

package/dist/types/sources/contentful.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { SharedSourceOptions, SourceFieldMap } from "./shared.ts";
+/** Options for {@link contentful}. */
+export interface ContentfulOptions extends SharedSourceOptions {
+    /** The content type id whose entries become pages. */
+    contentType: string;
+    /** Environment id. Defaults to `master`. */
+    environment?: string;
+    /**
+     * Field ids mapping an entry onto Blume meta + body; `sys.<key>` reaches
+     * the entry's `sys`. Defaults to `title` / `description` / `slug` / `body`
+     * / `sys.updatedAt`.
+     */
+    fields?: SourceFieldMap;
+    /** Locale code to fetch; omit for the space's default locale. */
+    locale?: string;
+    /** Extra query parameters for the entries request (`"fields.section": "sdk"`). */
+    params?: Record<string, string>;
+    /** Space id. */
+    space: string;
+}
+export declare const contentfulOptionsSchema: z.ZodObject<{
+    pollInterval: z.ZodOptional<z.ZodNumber>;
+    prefix: z.ZodOptional<z.ZodString>;
+    contentType: z.ZodString;
+    environment: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodObject<{
+        body: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        lastModified: z.ZodOptional<z.ZodString>;
+        slug: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    locale: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    space: z.ZodString;
+}, z.core.$strict>;
+export type ContentfulAdapter = AdapterDescriptor<"contentful", ContentfulOptions>;
+export declare const contentfulAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"contentful">;
+    options: z.ZodObject<{
+        pollInterval: z.ZodOptional<z.ZodNumber>;
+        prefix: z.ZodOptional<z.ZodString>;
+        contentType: z.ZodString;
+        environment: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodObject<{
+            body: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            lastModified: z.ZodOptional<z.ZodString>;
+            slug: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        locale: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        space: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A Contentful content type read through the Delivery API; rich text bodies
+ * become Markdown. The Delivery token comes from `CONTENTFUL_ACCESS_TOKEN`,
+ * and `--preview` reads drafts through the Preview API with
+ * `CONTENTFUL_PREVIEW_TOKEN`. Nothing to install: the adapter speaks the
+ * REST API directly.
+ */
+export declare const contentful: (options: ContentfulOptions) => ContentfulAdapter;

package/dist/types/sources/custom.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { ContentSource } from "../core/sources/types.ts";
+/** A user-provided {@link ContentSource} instance, validated for `name` + `load`. */
+export declare const customOptionsSchema: z.ZodCustom<ContentSource, ContentSource>;
+export type CustomAdapter = AdapterDescriptor<"custom", ContentSource>;
+export declare const customAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"custom">;
+    options: z.ZodCustom<ContentSource, ContentSource>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Any object implementing the {@link ContentSource} interface, passed straight
+ * through. This is the extension point for adapters with custom serializers or
+ * any other backend, without their SDKs touching core. Unlike the built-in
+ * adapters the descriptor carries a live instance, so it never travels through
+ * the generated project's data snapshot — the CLI consumes it at scan time.
+ */
+export declare const custom: (source: ContentSource) => CustomAdapter;

package/dist/types/sources/filesystem.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { SharedSourceOptions } from "./shared.ts";
+/** What `include` defaults to: every Markdown/MDX file under the root. */
+export declare const DEFAULT_CONTENT_INCLUDE: string[];
+/** What `exclude` defaults to: underscore- and dot-prefixed paths. */
+export declare const DEFAULT_CONTENT_EXCLUDE: string[];
+/** Options for {@link filesystem}. */
+export interface FilesystemOptions extends SharedSourceOptions {
+    /** Glob patterns to ignore. Defaults to `["**\/_*", "**\/.*"]`. */
+    exclude?: string[];
+    /** Glob patterns to include. Defaults to `["**\/*.{md,mdx}"]`. */
+    include?: string[];
+    /** Directory to read from, relative to the project root. Defaults to `docs`. */
+    root?: string;
+}
+export declare const filesystemOptionsSchema: z.ZodObject<{
+    pollInterval: z.ZodOptional<z.ZodNumber>;
+    prefix: z.ZodOptional<z.ZodString>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    root: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export type FilesystemAdapter = AdapterDescriptor<"filesystem", FilesystemOptions>;
+export declare const filesystemAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"filesystem">;
+    options: z.ZodObject<{
+        pollInterval: z.ZodOptional<z.ZodNumber>;
+        prefix: z.ZodOptional<z.ZodString>;
+        exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        root: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Local Markdown/MDX read from a directory. The zero-config default: with no
+ * `content.sources`, the top-level `content.root`/`include`/`exclude` desugar
+ * to exactly one of these.
+ */
+export declare const filesystem: (options?: FilesystemOptions) => FilesystemAdapter;

package/dist/types/sources/github-releases.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { SharedSourceOptions } from "./shared.ts";
+/** Options for {@link githubReleases}. */
+export interface GithubReleasesOptions extends SharedSourceOptions {
+    /** Include draft releases (needs a token with repo write access). */
+    drafts?: boolean;
+    /** Cap the number of releases materialized, newest-first. Defaults to 100. */
+    limit?: number;
+    /** Repository owner (user or org). */
+    owner: string;
+    /** Include prereleases. */
+    prereleases?: boolean;
+    /** Repository name. */
+    repo: string;
+}
+export declare const githubReleasesOptionsSchema: z.ZodObject<{
+    pollInterval: z.ZodOptional<z.ZodNumber>;
+    prefix: z.ZodOptional<z.ZodString>;
+    drafts: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    owner: z.ZodString;
+    prereleases: z.ZodOptional<z.ZodBoolean>;
+    repo: z.ZodString;
+}, z.core.$strict>;
+export type GithubReleasesAdapter = AdapterDescriptor<"github-releases", GithubReleasesOptions>;
+export declare const githubReleasesAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"github-releases">;
+    options: z.ZodObject<{
+        pollInterval: z.ZodOptional<z.ZodNumber>;
+        prefix: z.ZodOptional<z.ZodString>;
+        drafts: z.ZodOptional<z.ZodBoolean>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        owner: z.ZodString;
+        prereleases: z.ZodOptional<z.ZodBoolean>;
+        repo: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A repo's GitHub Releases, materialized as `type: changelog` entries — release
+ * notes become the changelog with no files to maintain. A private repo reads a
+ * token from `GITHUB_TOKEN`; it is never inlined here.
+ */
+export declare const githubReleases: (options: GithubReleasesOptions) => GithubReleasesAdapter;

package/dist/types/sources/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Content source adapters for `blume.config.ts`:
+ *
+ * ```ts
+ * import { defineConfig } from "blume";
+ * import { filesystem, githubReleases } from "blume/sources";
+ *
+ * export default defineConfig({
+ *   content: {
+ *     sources: [
+ *       filesystem({ root: "docs" }),
+ *       githubReleases({ owner: "acme", repo: "sdk", prefix: "changelog" }),
+ *     ],
+ *   },
+ * });
+ * ```
+ *
+ * Each factory returns a plain descriptor (see `core/adapter.ts`) that the
+ * schema validates and the CLI reads at scan time; every consumer — the
+ * generated `.blume/package.json`, the secrets check, `blume doctor` — reads
+ * the descriptor's `runtimeDeps` and `requiredSecrets` instead of switching
+ * on a source name. `custom()` is the exception that carries a live
+ * {@link ContentSource} instance rather than JSON.
+ */
+export type { AdapterDescriptor } from "../core/adapter.ts";
+export type { ContentSource, SourceContext, SourceEntry, SourceLoadResult, } from "../core/sources/types.ts";
+export { contentful } from "./contentful.ts";
+export type { ContentfulAdapter, ContentfulOptions } from "./contentful.ts";
+export { custom } from "./custom.ts";
+export type { CustomAdapter } from "./custom.ts";
+export { filesystem } from "./filesystem.ts";
+export type { FilesystemAdapter, FilesystemOptions } from "./filesystem.ts";
+export { githubReleases } from "./github-releases.ts";
+export type { GithubReleasesAdapter, GithubReleasesOptions, } from "./github-releases.ts";
+export { mdxRemote } from "./mdx-remote.ts";
+export type { MdxRemoteAdapter, MdxRemoteOptions } from "./mdx-remote.ts";
+export { notion } from "./notion.ts";
+export type { NotionAdapter, NotionOptions } from "./notion.ts";
+export { obsidian } from "./obsidian.ts";
+export type { ObsidianAdapter, ObsidianOptions } from "./obsidian.ts";
+export { payload } from "./payload.ts";
+export type { PayloadAdapter, PayloadOptions } from "./payload.ts";
+export type { AnySourceAdapter, ContentSourceAdapter, SourceAdapterKind, } from "./registry.ts";
+export { sanity } from "./sanity.ts";
+export type { SanityAdapter, SanityOptions } from "./sanity.ts";
+export type { SharedSourceOptions, SourceFieldMap } from "./shared.ts";
+export { strapi } from "./strapi.ts";
+export type { StrapiAdapter, StrapiOptions } from "./strapi.ts";

package/dist/types/sources/mdx-remote.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { SharedSourceOptions } from "./shared.ts";
+/** Options for {@link mdxRemote}. */
+export interface MdxRemoteOptions extends SharedSourceOptions {
+    /** Explicit list of source-relative file paths to fetch from `url`. */
+    files?: string[];
+    /** Enumerate a GitHub repo subtree via the git-trees API. */
+    github?: {
+        /** Repository owner (user or org). */
+        owner: string;
+        /** Subpath within the repo. Defaults to the repo root. */
+        path?: string;
+        /** Git ref (branch, tag, or SHA). Defaults to `main`. */
+        ref?: string;
+        /** Repository name. */
+        repo: string;
+    };
+    /** Glob patterns applied to enumerated refs. Defaults to `["**\/*.{md,mdx}"]`. */
+    include?: string[];
+    /** Raw base URL, e.g. `https://raw.githubusercontent.com/acme/sdk/main/docs`. */
+    url?: string;
+}
+export declare const mdxRemoteOptionsSchema: z.ZodObject<{
+    pollInterval: z.ZodOptional<z.ZodNumber>;
+    prefix: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    github: z.ZodOptional<z.ZodObject<{
+        owner: z.ZodString;
+        path: z.ZodDefault<z.ZodString>;
+        ref: z.ZodDefault<z.ZodString>;
+        repo: z.ZodString;
+    }, z.core.$strict>>;
+    include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type MdxRemoteAdapter = AdapterDescriptor<"mdx-remote", MdxRemoteOptions>;
+export declare const mdxRemoteAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"mdx-remote">;
+    options: z.ZodObject<{
+        pollInterval: z.ZodOptional<z.ZodNumber>;
+        prefix: z.ZodOptional<z.ZodString>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        github: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            path: z.ZodDefault<z.ZodString>;
+            ref: z.ZodDefault<z.ZodString>;
+            repo: z.ZodString;
+        }, z.core.$strict>>;
+        include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Remote Markdown/MDX fetched over HTTP. Enumerate files explicitly against a
+ * raw `url` base, or from a GitHub repo subtree via `github`. A private repo's
+ * token comes from `GITHUB_TOKEN` — never inline it here. The adapter declares
+ * the variable only when it reads from GitHub, since a `url` on any other host
+ * is never sent the token.
+ */
+export declare const mdxRemote: (options: MdxRemoteOptions) => MdxRemoteAdapter;

package/dist/types/sources/notion.d.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { SharedSourceOptions } from "./shared.ts";
+/** Options for {@link notion}. */
+export interface NotionOptions extends SharedSourceOptions {
+    /** Max concurrent Notion API requests; default 3 (Notion's per-integration pace). */
+    concurrency?: number;
+    /** Notion database id. */
+    database: string;
+    /** Notion property names mapped onto Blume meta. */
+    properties?: {
+        /** Property holding the page description. */
+        description?: string;
+        /** Property holding the sort order. */
+        order?: string;
+        /** Property holding the page slug. */
+        slug?: string;
+        /** Property holding the publish status. */
+        status?: string;
+        /** Property holding the page title. */
+        title?: string;
+    };
+    /** Status value treated as published; others map to `draft`. Defaults to `Published`. */
+    publishedValue?: string;
+}
+export declare const notionOptionsSchema: z.ZodObject<{
+    pollInterval: z.ZodOptional<z.ZodNumber>;
+    prefix: z.ZodOptional<z.ZodString>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+    database: z.ZodString;
+    properties: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodString>;
+        slug: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    publishedValue: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type NotionAdapter = AdapterDescriptor<"notion", NotionOptions>;
+export declare const notionAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"notion">;
+    options: z.ZodObject<{
+        pollInterval: z.ZodOptional<z.ZodNumber>;
+        prefix: z.ZodOptional<z.ZodString>;
+        concurrency: z.ZodOptional<z.ZodNumber>;
+        database: z.ZodString;
+        properties: z.ZodOptional<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodString>;
+            slug: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        publishedValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A Notion database; pages become entries, blocks become MDX. `@notionhq/client`
+ * is the declared runtime dependency, and the integration token comes from
+ * `NOTION_TOKEN`.
+ */
+export declare const notion: (options: NotionOptions) => NotionAdapter;

package/dist/types/sources/obsidian.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { SharedSourceOptions } from "./shared.ts";
+/** Options for {@link obsidian}. */
+export interface ObsidianOptions extends SharedSourceOptions {
+    /** Vault folder names to skip at any depth, in addition to dot-folders. */
+    exclude?: string[];
+    /** Vault directory, absolute or relative to the project root. */
+    vault: string;
+}
+export declare const obsidianOptionsSchema: z.ZodObject<{
+    pollInterval: z.ZodOptional<z.ZodNumber>;
+    prefix: z.ZodOptional<z.ZodString>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    vault: z.ZodString;
+}, z.core.$strict>;
+export type ObsidianAdapter = AdapterDescriptor<"obsidian", ObsidianOptions>;
+export declare const obsidianAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"obsidian">;
+    options: z.ZodObject<{
+        pollInterval: z.ZodOptional<z.ZodNumber>;
+        prefix: z.ZodOptional<z.ZodString>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        vault: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * An Obsidian vault, read in place. Wikilinks become route links and
+ * `%%comments%%` are stripped at load time, so the vault stays the source of
+ * truth — no export step and no generated notes in the repo.
+ */
+export declare const obsidian: (options: ObsidianOptions) => ObsidianAdapter;

package/dist/types/sources/payload.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import type { SharedSourceOptions, SourceFieldMap } from "./shared.ts";
+/** Options for {@link payload}. */
+export interface PayloadOptions extends SharedSourceOptions {
+    /**
+     * The auth-enabled collection the API key belongs to. Defaults to `users`;
+     * it names the scheme in the `Authorization` header (`users API-Key <key>`).
+     */
+    authCollection?: string;
+    /** The collection slug whose documents become pages. */
+    collection: string;
+    /** Relationship depth to populate. Defaults to `1`, enough for upload URLs. */
+    depth?: number;
+    /**
+     * Field paths mapping a document onto Blume meta + body. Defaults to
+     * `title` / `description` / `slug` / `content` / `updatedAt`.
+     */
+    fields?: SourceFieldMap;
+    /** Extra query parameters for the collection request (`"where[status][equals]": "live"`). */
+    params?: Record<string, string>;
+    /** The Payload app's origin (`https://cms.acme.dev`); its REST API is at `/api`. */
+    url: string;
+}
+export declare const payloadOptionsSchema: z.ZodObject<{
+    pollInterval: z.ZodOptional<z.ZodNumber>;
+    prefix: z.ZodOptional<z.ZodString>;
+    authCollection: z.ZodOptional<z.ZodString>;
+    collection: z.ZodString;
+    depth: z.ZodOptional<z.ZodNumber>;
+    fields: z.ZodOptional<z.ZodObject<{
+        body: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        lastModified: z.ZodOptional<z.ZodString>;
+        slug: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    url: z.ZodString;
+}, z.core.$strict>;
+export type PayloadAdapter = AdapterDescriptor<"payload", PayloadOptions>;
+export declare const payloadAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"payload">;
+    options: z.ZodObject<{
+        pollInterval: z.ZodOptional<z.ZodNumber>;
+        prefix: z.ZodOptional<z.ZodString>;
+        authCollection: z.ZodOptional<z.ZodString>;
+        collection: z.ZodString;
+        depth: z.ZodOptional<z.ZodNumber>;
+        fields: z.ZodOptional<z.ZodObject<{
+            body: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            lastModified: z.ZodOptional<z.ZodString>;
+            slug: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        url: z.ZodString;
+    }, z.core.$strict>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A Payload collection read through its REST API; Lexical bodies become
+ * Markdown. The API key comes from `PAYLOAD_API_KEY`, and `--preview` reads
+ * drafts. Nothing to install: the adapter speaks the REST API directly.
+ */
+export declare const payload: (options: PayloadOptions) => PayloadAdapter;