kennel 0.2.1 → 0.2.2

package/README.md

@@ -26,6 +26,7 @@ kennel view /path/to/workspace
 kennel serve /path/to/workspace
 kennel dev /path/to/docs-site --config index.json
 kennel init .
+kennel plugin add https://github.com/example/kennel-transcripts-plugin.git#main
 kennel core-folders .
 kennel mcp generate . --config index.json
 kennel publish init cloudflare .
@@ -74,6 +75,15 @@ Entity search reads allowed local roots from
 }
 ```
 
+The same user config stores trusted external folder plugins added with
+`kennel plugin add <git-repository-url[#ref]>`. The command pins the requested
+ref, or `HEAD` with no fragment, to a full commit, validates package metadata
+and explicit client/server/manifest exports, builds the composed kernel in the
+XDG cache, and only then atomically updates config. Installed plugin imports are
+derived from package metadata, not from URL text. The transcripts plugin
+contract is package `kennel-transcripts-plugin`, id `memos`, trigger
+`memos.json`.
+
 When this file is absent, entity search allows only the workspace opened by
 `knl`. Invalid config fails closed.
 
@@ -96,11 +106,14 @@ diagnostics come from the declared schema and Markdown frontmatter. Pass
 list. See [Core folders and metadata indexing](../docs/core-folders.md) for
 patterns, parser support, navigation labels and refresh semantics.
 
-`kennel view` starts the source Vite viewer from a Kennel checkout. React and
-CSS changes use HMR. Changes to schema and content files cause a metadata
-refetch without a full page reload. `kennel serve` starts the packaged static
-viewer. The hot viewer uses the current directory when no folder is given. It
-also reuses a Kennel Vite server that already runs on the selected port.
+`kennel view` starts the source Vite viewer from a Kennel checkout when no
+external plugins are installed. React and CSS changes use HMR. Changes to
+schema and content files cause a metadata refetch without a full page reload.
+When external plugins are installed, `kennel view` uses the composed static
+kernel so `view`, `pop`, `serve`, default, `core`, and `init` all use the same
+kernel key. `kennel serve` starts the packaged static viewer. The hot viewer
+uses the current directory when no folder is given. It also reuses a Kennel Vite
+server that already runs on the selected port.
 
 `kennel publish init cloudflare` is the exception for deploy wiring: it scaffolds
 a Cloudflare Worker email-code gate for an existing docs workspace by writing

package/dist/cli/dispatch.js

@@ -11,6 +11,15 @@ export async function dispatch(argv) {
         await viewer([]);
         return;
     }
+    if (command === 'plugin' && args[0] === 'add') {
+        const url = args[1];
+        if (!url || args.length !== 2)
+            throw new Error('Usage: kennel plugin add <git-repository-url>');
+        const { installExternalPlugin } = await import('../plugins/external.js');
+        const plugin = await installExternalPlugin(url);
+        console.log(`Installed plugin ${plugin.id} from ${plugin.packageName} at ${plugin.commit}`);
+        return;
+    }
     if (command === 'core') {
         const { core } = await import('../core/command.js');
         await core(args);

package/dist/cli/src/automations/notifications.d.ts

@@ -0,0 +1,40 @@
+export type SlackMessageResult = {
+    ts: string;
+};
+export type EmailSendRequest = {
+    notificationType?: string;
+    preheader?: string;
+    priority?: string;
+    recipients: string[];
+    subject: string;
+    template?: string;
+    text: string;
+};
+export type CloudflareEmailSenderOptions = {
+    endpoint: string;
+    fetch?: typeof fetch;
+    token: string;
+};
+export type SlackNotifierOptions = {
+    fetch?: typeof fetch;
+    token: string;
+};
+export declare function readEmailRecipients(filePath: string, root?: string): Promise<string[]>;
+export declare function createSlackNotifier({ fetch: fetchImpl, token }: SlackNotifierOptions): ({ channelId, text, }: {
+    channelId: string;
+    text: string;
+}) => Promise<SlackMessageResult>;
+export declare function createCloudflareEmailSender({ endpoint, fetch: fetchImpl, token, }: CloudflareEmailSenderOptions): ({ notificationType, preheader, priority, recipients, subject, template, text }: EmailSendRequest) => Promise<any>;
+export declare function sendEmail({ recipients, sendmailPath, subject, text, }: EmailSendRequest & {
+    sendmailPath?: string;
+}): Promise<{
+    recipients: string[];
+    provider: string;
+}>;
+export declare function markdownToEmailHtml(markdown: string): string;
+export declare function formatSendSummary({ emailRecipients, emailSent, slackChannelId, slackTs, }: {
+    emailRecipients: string[];
+    emailSent: boolean;
+    slackChannelId: string;
+    slackTs?: string;
+}): string;

package/dist/cli/src/automations/notifications.js

@@ -0,0 +1,220 @@
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { isAbsolute, resolve } from 'node:path';
+const SLACK_API_BASE_URL = 'https://slack.com/api/';
+export async function readEmailRecipients(filePath, root = process.cwd()) {
+    const text = await readFile(isAbsolute(filePath) ? filePath : resolve(root, filePath), 'utf8');
+    return text
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#'));
+}
+export function createSlackNotifier({ fetch: fetchImpl = fetch, token }) {
+    return async function postSlackMessage({ channelId, text, }) {
+        const response = await fetchImpl(new URL('chat.postMessage', SLACK_API_BASE_URL), {
+            body: JSON.stringify({
+                channel: channelId,
+                text,
+            }),
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json; charset=utf-8',
+            },
+            method: 'POST',
+        });
+        const body = (await response.json());
+        if (!body.ok) {
+            throw new Error(`Slack chat.postMessage failed: ${body.error ?? JSON.stringify(body)}`);
+        }
+        return { ts: body.ts };
+    };
+}
+export function createCloudflareEmailSender({ endpoint, fetch: fetchImpl = fetch, token, }) {
+    return async function sendCloudflareEmail({ notificationType, preheader, priority, recipients, subject, template, text }) {
+        if (recipients.length === 0) {
+            throw new Error('No email recipients configured.');
+        }
+        const response = await fetchImpl(endpoint, {
+            body: JSON.stringify({
+                html: markdownToEmailHtml(text),
+                ...(notificationType ? { notificationType } : {}),
+                ...(preheader ? { preheader } : {}),
+                ...(priority ? { priority } : {}),
+                subject,
+                ...(template ? { template } : {}),
+                text,
+                to: recipients,
+            }),
+            headers: {
+                authorization: `Bearer ${token}`,
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        });
+        const body = await response.json().catch(async () => ({ error: await response.text() }));
+        if (!response.ok) {
+            throw new Error(`Cloudflare email failed (${response.status}): ${JSON.stringify(body)}`);
+        }
+        return body;
+    };
+}
+export async function sendEmail({ recipients, sendmailPath = process.env.SENDMAIL_PATH ?? '/usr/sbin/sendmail', subject, text, }) {
+    if (recipients.length === 0) {
+        throw new Error('No email recipients configured.');
+    }
+    if (process.env.CLOUDFLARE_EMAIL_ENDPOINT && process.env.CLOUDFLARE_EMAIL_TOKEN) {
+        const sender = createCloudflareEmailSender({
+            endpoint: process.env.CLOUDFLARE_EMAIL_ENDPOINT,
+            token: process.env.CLOUDFLARE_EMAIL_TOKEN,
+        });
+        await sender({ recipients, subject, text });
+        return { recipients, provider: 'cloudflare' };
+    }
+    const message = [
+        `To: ${recipients.join(', ')}`,
+        `Subject: ${sanitizeHeader(subject)}`,
+        'Content-Type: text/plain; charset=utf-8',
+        '',
+        text,
+    ].join('\n');
+    await runSendmail(sendmailPath, message);
+    return { recipients, provider: 'sendmail' };
+}
+export function markdownToEmailHtml(markdown) {
+    const lines = markdown.replace(/\r\n/gu, '\n').split('\n');
+    const blocks = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line.trim() === '') {
+            continue;
+        }
+        const codeFence = line.match(/^```([a-zA-Z0-9_-]*)\s*$/u);
+        if (codeFence) {
+            const code = [];
+            index += 1;
+            while (index < lines.length && !lines[index].startsWith('```')) {
+                code.push(lines[index]);
+                index += 1;
+            }
+            const language = codeFence[1] ? ` class="language-${escapeAttribute(codeFence[1])}"` : '';
+            blocks.push(`<pre><code${language}>${escapeHtml(code.join('\n').trim())}</code></pre>`);
+            continue;
+        }
+        if (isTableHeader(lines, index)) {
+            const { html, nextIndex } = renderTable(lines, index);
+            blocks.push(html);
+            index = nextIndex;
+            continue;
+        }
+        if (line.startsWith('- ')) {
+            const items = [];
+            while (index < lines.length && lines[index].startsWith('- ')) {
+                items.push(`<li>${renderInline(lines[index].slice(2))}</li>`);
+                index += 1;
+            }
+            blocks.push(`<ul>\n${items.join('\n')}\n</ul>`);
+            index -= 1;
+            continue;
+        }
+        const paragraph = [line];
+        while (index + 1 < lines.length &&
+            lines[index + 1].trim() !== '' &&
+            !lines[index + 1].startsWith('- ') &&
+            !lines[index + 1].startsWith('```') &&
+            !isTableHeader(lines, index + 1)) {
+            paragraph.push(lines[index + 1]);
+            index += 1;
+        }
+        blocks.push(`<p>${paragraph.map(renderInline).join('<br>')}</p>`);
+    }
+    return `<!doctype html>
+<html>
+<body style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; line-height: 1.45; color: #111827;">
+${blocks.join('\n')}
+</body>
+</html>`;
+}
+export function formatSendSummary({ emailRecipients, emailSent, slackChannelId, slackTs, }) {
+    const parts = [
+        slackTs ? `Slack posted to ${slackChannelId} at ${slackTs}` : `Slack not posted to ${slackChannelId}`,
+        emailSent ? `email sent to ${emailRecipients.join(', ')}` : 'email not sent',
+    ];
+    return parts.join('; ');
+}
+async function runSendmail(sendmailPath, message) {
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn(sendmailPath, ['-t'], {
+            stdio: ['pipe', 'ignore', 'pipe'],
+        });
+        let stderr = '';
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolvePromise();
+                return;
+            }
+            reject(new Error(`sendmail exited with code ${code}: ${stderr.trim()}`));
+        });
+        child.stdin.end(message);
+    });
+}
+function isTableHeader(lines, index) {
+    return hasTableCells(lines[index]) && Boolean(lines[index + 1] && isTableDivider(lines[index + 1]));
+}
+function renderTable(lines, startIndex) {
+    const headers = splitTableRow(lines[startIndex]);
+    const rows = [];
+    let index = startIndex + 2;
+    while (index < lines.length && hasTableCells(lines[index]) && lines[index].trim() !== '') {
+        rows.push(splitTableRow(lines[index]));
+        index += 1;
+    }
+    const html = [
+        '<table style="border-collapse: collapse; margin: 12px 0;">',
+        '<thead>',
+        `<tr>${headers
+            .map((header) => `<th style="border: 1px solid #d1d5db; padding: 4px 8px; text-align: left;">${renderInline(header)}</th>`)
+            .join('')}</tr>`,
+        '</thead>',
+        '<tbody>',
+        ...rows.map((row) => `<tr>${headers
+            .map((_, cellIndex) => `<td style="border: 1px solid #d1d5db; padding: 4px 8px;">${renderInline(row[cellIndex] ?? '')}</td>`)
+            .join('')}</tr>`),
+        '</tbody>',
+        '</table>',
+    ].join('\n');
+    return { html, nextIndex: index - 1 };
+}
+function hasTableCells(line) {
+    return Boolean(line && line.includes('|'));
+}
+function isTableDivider(line) {
+    return splitTableRow(line).every((cell) => /^:?-{3,}:?$/u.test(cell));
+}
+function splitTableRow(line) {
+    return line
+        .trim()
+        .replace(/^\|/u, '')
+        .replace(/\|$/u, '')
+        .split('|')
+        .map((cell) => cell.trim());
+}
+function renderInline(value) {
+    return escapeHtml(value).replace(/\*([^*\n]+)\*/gu, '<strong>$1</strong>');
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/gu, '&amp;')
+        .replace(/</gu, '&lt;')
+        .replace(/>/gu, '&gt;')
+        .replace(/"/gu, '&quot;');
+}
+function escapeAttribute(value) {
+    return escapeHtml(value).replace(/'/gu, '&#39;');
+}
+function sanitizeHeader(value) {
+    return value.replace(/[\r\n]+/gu, ' ').trim();
+}

package/dist/cli/src/cli/dispatch.d.ts

@@ -0,0 +1 @@
+export declare function dispatch(argv: string[]): Promise<void>;

package/dist/cli/src/cli/dispatch.js

@@ -0,0 +1,125 @@
+import { existsSync } from 'node:fs';
+import { usage } from './usage.js';
+export async function dispatch(argv) {
+    const [, , command, ...args] = argv;
+    if (command === '-h' || command === '--help') {
+        usage();
+        return;
+    }
+    if (!command) {
+        const { viewer } = await import('../site/viewer.js');
+        await viewer([]);
+        return;
+    }
+    if (command === 'plugin' && args[0] === 'add') {
+        const url = args[1];
+        if (!url || args.length !== 2)
+            throw new Error('Usage: kennel plugin add <git-repository-url>');
+        const { installExternalPlugin } = await import('../plugins/external.js');
+        const plugin = await installExternalPlugin(url);
+        console.log(`Installed plugin ${plugin.id} from ${plugin.packageName} at ${plugin.commit}`);
+        return;
+    }
+    if (command === 'core') {
+        const { core } = await import('../core/command.js');
+        await core(args);
+        return;
+    }
+    if (command === 'init') {
+        const { init } = await import('../core/init.js');
+        await init(args);
+        return;
+    }
+    if (command === 'core-folders') {
+        const { coreFolders } = await import('../core/core-folders.js');
+        await coreFolders(args);
+        return;
+    }
+    if (command === 'view') {
+        const { viewer } = await import('../site/viewer.js');
+        await viewer(['--hot', ...args]);
+        return;
+    }
+    if (command === 'pop' || command === 'p') {
+        const { viewer } = await import('../site/viewer.js');
+        // Single-file pop. Prints a clickable URL; pass --open to open the
+        // default browser (never automatic — agents would stack tabs).
+        await viewer([...args]);
+        return;
+    }
+    if (command === 'open' || command === 'o') {
+        const { viewer } = await import('../site/viewer.js');
+        // Hot viewer. Prints a clickable URL; pass --open to open the browser.
+        await viewer(['--hot', ...args]);
+        return;
+    }
+    if (command === 'mail') {
+        const { mail } = await import('../site/mail.js');
+        await mail(args);
+        return;
+    }
+    if (command === 'serve') {
+        const { viewer } = await import('../site/viewer.js');
+        await viewer(['--static', ...args]);
+        return;
+    }
+    if (command === 'share') {
+        // Deliberate remote share (LAN default; --tailscale for outside the
+        // house). Runs a second remote-scoped static server; the plain 5180
+        // viewer stays loopback-only.
+        const { share } = await import('../package/preview.js');
+        await share(args);
+        return;
+    }
+    if (command === 'dev') {
+        const { dev } = await import('../site/dev.js');
+        dev(args);
+        return;
+    }
+    if (command === 'extension' && args[0] === 'install') {
+        const { extensionInstall } = await import('../site/extension.js');
+        await extensionInstall();
+        return;
+    }
+    if (command === 'mcp' && args[0] === 'generate') {
+        const { generateMcp } = await import('../mcp/generate.js');
+        await generateMcp(args.slice(1));
+        return;
+    }
+    if (command === 'publish' && args[0] === 'init' && args[1] === 'cloudflare') {
+        const { publishInitCloudflare } = await import('../publish/cloudflare-init.js');
+        publishInitCloudflare(args.slice(2));
+        return;
+    }
+    if (command === 'publish' && args[0] === 'init' && args[1] === 'vercel') {
+        const { publishInitVercel } = await import('../publish/vercel-init.js');
+        publishInitVercel(args.slice(2));
+        return;
+    }
+    if (command === 'publish') {
+        const { publish } = await import('../deploy/cloudflare.js');
+        publish(args);
+        return;
+    }
+    if (command === 'deploy') {
+        const { deploy } = await import('../deploy/cloudflare.js');
+        deploy(args);
+        return;
+    }
+    if (command === 'dp') {
+        const { deploy } = await import('../deploy/cloudflare.js');
+        deploy(args);
+        return;
+    }
+    // Positionals that are flags or existing paths still go straight to the
+    // viewer (`kennel [folder]`, `kennel note.md`, `kennel --lan .`). Unknown
+    // command words fail loudly instead of silently opening a viewer.
+    if (command.startsWith('-') || existsSync(command)) {
+        const { viewer } = await import('../site/viewer.js');
+        await viewer([command, ...args]);
+        return;
+    }
+    console.error(`Unknown command: ${command}\n`);
+    usage();
+    process.exitCode = 1;
+}

package/dist/cli/src/cli/usage.d.ts

@@ -0,0 +1 @@
+export declare function usage(): void;

package/dist/cli/src/cli/usage.js

@@ -0,0 +1,25 @@
+export function usage() {
+    console.log(`Usage:
+  knl core [folder] [--host <host>] [--port <port>] [--api-only]
+  kennel init [path] [--plugin <id>] [--force] [--list]
+  kennel plugin add <git-repository-url>
+  kennel core-folders [path] [--json]
+  kennel [folder] [--host <host>] [--port <port>] [--lan|--tailscale]
+  kennel pop|p <file|folder> [--open] [--watch] [--host <host>] [--port <port>] [--lan|--tailscale]
+  kennel view [folder] [--host <host>] [--port <port>] [--dry-run]
+  kennel open|o [folder] [--open] [--host <host>] [--port <port>] [--dry-run]
+  kennel mail [folder] [--open] [--host <host>] [--port <port>] [--dry-run]
+  kennel serve [folder] [--host <host>] [--port <port>] [--lan|--tailscale]
+  kennel share [folder] [--lan|--tailscale] [--port <port>] [--dry-run]
+  kennel dev [path] [--config <json-file>] [--port <port>] [--script <script>] [--dry-run] [-- <args...>]
+  kennel extension install
+  kennel mcp generate [path] [--config <json-file>] [--data-only|--function-only]
+  kennel publish init cloudflare [path] [--config <json-file>] [--force] [--hostname <hostname>]
+  kennel publish init vercel [path] [--config <json-file>] [--force] [--hostname <hostname>]
+  kennel publish [path] [--config <json-file>] [--dry-run] [--force] [--hostname <hostname>] [--test-email <email>] [--skip-test] [--use-doppler-token]
+  kennel publish cloudflare [path] [--config <json-file>] [--dry-run] [--force] [--hostname <hostname>] [--test-email <email>] [--skip-test] [--use-doppler-token]
+  kennel publish vercel [path] [--config <json-file>] [--dry-run] [--force] [--hostname <hostname>] [--skip-test]
+  kennel deploy [path] [--config <json-file>] [legacy alias for publish]
+  kennel dp [path] [--config <json-file>] [legacy alias for publish]
+`);
+}

package/dist/cli/src/core/api-client.d.ts

@@ -0,0 +1,13 @@
+/** Replaced at build time by the Node bundle of packages/api-client/src/index.ts. */
+import type { operations } from '../../../packages/api-client/src/generated.js';
+type JsonResponse<K extends 'health' | 'documents'> = operations[K]['responses'][200]['content']['application/json'];
+type RequestOptions = {
+    signal?: AbortSignal;
+};
+export declare function createKennelClient(options: {
+    baseUrl: string;
+}): {
+    health(options?: RequestOptions): Promise<JsonResponse<'health'>>;
+    documents(href: string, options?: RequestOptions): Promise<JsonResponse<'documents'>>;
+};
+export {};

package/dist/cli/src/core/api-client.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/core/command.d.ts

@@ -0,0 +1 @@
+export declare function core(args: string[]): Promise<void>;

package/dist/cli/src/core/command.js

@@ -0,0 +1,69 @@
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { createKennelApi } from "./runtime.js";
+export async function core(args) {
+    let root = process.cwd();
+    let host = "127.0.0.1";
+    let port = 5181;
+    let apiOnly = false;
+    let folderSet = false;
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (arg === "--help" || arg === "-h") {
+            console.log("Usage: knl core [folder] [--port 5181] [--host 127.0.0.1] [--api-only]\nNon-loopback hosts restrict reads to folder and disable host actions/ACP.");
+            return;
+        }
+        if (arg === "--api-only") {
+            apiOnly = true;
+            continue;
+        }
+        if (arg === "--host" || arg === "--port") {
+            const value = args[++index];
+            if (!value || value.startsWith("--"))
+                throw new Error(`Missing value for ${arg}`);
+            if (arg === "--host")
+                host = value;
+            else {
+                port = Number(value);
+                if (!Number.isInteger(port) || port < 1 || port > 65535)
+                    throw new Error("Invalid port");
+            }
+            continue;
+        }
+        if (!arg || arg.startsWith("-") || folderSet)
+            throw new Error(`Unexpected argument: ${arg}`);
+        root = resolve(arg);
+        folderSet = true;
+    }
+    root = realpathSync(root);
+    if (!statSync(root).isDirectory())
+        throw new Error("Core root must be a directory");
+    const { ensureKernel } = await import("../plugins/external.js");
+    const kernel = await ensureKernel();
+    const webRoot = kernel.webRoot;
+    if (!apiOnly && !existsSync(resolve(webRoot, "index.html")))
+        throw new Error("Web assets missing; build the CLI or use --api-only");
+    process.env.KENNEL_KERNEL_KEY = kernel.key;
+    process.env.KENNEL_EXTERNAL_SERVER_ENTRIES = JSON.stringify(kernel.serverEntries);
+    const api = createKennelApi({
+        root,
+        host,
+        webRoot: apiOnly ? undefined : webRoot,
+    });
+    try {
+        await api.listen(port);
+        console.log(`Kennel core: http://${host.includes(":") ? `[${host}]` : host}:${port}`);
+        await new Promise((done) => {
+            const stop = () => {
+                process.off("SIGINT", stop);
+                process.off("SIGTERM", stop);
+                done();
+            };
+            process.once("SIGINT", stop);
+            process.once("SIGTERM", stop);
+        });
+    }
+    finally {
+        await api.close();
+    }
+}

package/dist/cli/src/core/core-folders.d.ts

@@ -0,0 +1 @@
+export declare function coreFolders(args: string[]): Promise<void>;

package/dist/cli/src/core/core-folders.js

@@ -0,0 +1,42 @@
+import { realpath } from 'node:fs/promises';
+import { relative, resolve } from 'node:path';
+import { createCoreFolderIndex } from '@raggle-ai/schemas/node';
+export async function coreFolders(args) {
+    let folder;
+    let json = false;
+    for (const arg of args) {
+        if (arg === '--json' || arg === '-j')
+            json = true;
+        else if (arg === '--help' || arg === '-h') {
+            console.log(`Usage: kennel core-folders [path] [--json]
+
+List indexed schema collections and their records (default: current directory).
+--json emits collection IDs, metadata, records, revisions and diagnostics.`);
+            return;
+        }
+        else if (arg.startsWith('-'))
+            throw new Error(`Unknown flag: ${arg}`);
+        else if (folder)
+            throw new Error('Only one folder may be specified');
+        else
+            folder = arg;
+    }
+    const root = await realpath(resolve(folder ?? '.'));
+    const result = await createCoreFolderIndex().list(root);
+    if (json) {
+        console.log(JSON.stringify(result.collections, null, 2));
+        return;
+    }
+    console.log(`Core folders in ${root}\n`);
+    if (!result.collections.length)
+        console.log('None. Declare core folders in raggle.json.');
+    for (const collection of result.collections) {
+        console.log(`${collection.title} (${relative(root, collection.folder) || '.'}) — ${collection.count} records`);
+        for (const record of collection.records) {
+            console.log(`  - ${record.title}${record.validationErrors.length ? ' [invalid metadata]' : ''}`);
+        }
+        for (const diagnostic of collection.diagnostics)
+            console.log(`  ! ${diagnostic.message}`);
+        console.log();
+    }
+}

package/dist/cli/src/core/init.d.ts

@@ -0,0 +1 @@
+export declare function init(args: string[]): Promise<void>;