npm - @promptbook/cli - Versions diffs - 0.113.0-9 → 0.114.0-0 - Mend

@promptbook/cli 0.113.0-9 → 0.114.0-0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1040) hide show

package/apps/agents-server/src/utils/bookLanguageDocumentation/createBookLanguageDocumentationPdfResponse.ts ADDED Viewed

@@ -0,0 +1,160 @@
+import { NextResponse } from 'next/server';
+import { spaceTrim } from 'spacetrim';
+import { getPromptbookExportBranding } from '../../../../../src/book-components/Chat/save/_common/getPromptbookExportBranding';
+import { renderMarkdown } from '../../../../../src/book-components/Chat/utils/renderMarkdown';
+import type { string_markdown } from '../../../../../src/types/string_markdown';
+import { escapeHtml } from '../../../../../src/utils/html/escapeHtml';
+import { getPromptbookLogoDataUrl } from '../pdf/getPromptbookLogoDataUrl';
+import { renderHtmlToPdfOnServer } from '../pdf/renderHtmlToPdfOnServer';
+import {
+    createBookLanguageDocumentationExport,
+    type BookLanguageDocumentationExportOptions,
+} from './createBookLanguageDocumentationMarkdownResponse';
+import { createBookLanguageDocumentationPdfStyles } from './createBookLanguageDocumentationPdfStyles';
+import { groupHtmlHeadingSections } from './groupHtmlHeadingSections';
+import { highlightBookCodeBlocksInHtml } from './highlightBookCodeBlocksInHtml';
+/**
+ * Shared Promptbook branding embedded into standalone exports.
+ *
+ * @private internal type of Book language PDF export
+ */
+type PromptbookExportBranding = ReturnType<typeof getPromptbookExportBranding>;
+/**
+ * Everything needed to render the standalone Book language manual as HTML.
+ */
+export type CreateBookLanguageDocumentationPdfHtmlOptions = {
+    /**
+     * Manual content generated from the core Book language registry.
+     */
+    readonly markdown: string_markdown;
+    /**
+     * Language metadata selected by the person exporting the manual.
+     */
+    readonly language: string;
+    /**
+     * Inline Promptbook logo, or `null` when the asset could not be embedded.
+     */
+    readonly logoDataUrl: string | null;
+};
+/**
+ * Creates a PDF response for a Book language manual.
+ *
+ * @param options - Agent selection and language shared by manual export formats.
+ * @returns Ready-to-download PDF response.
+ */
+export async function createBookLanguageDocumentationPdfResponse(
+    options: BookLanguageDocumentationExportOptions,
+): Promise<NextResponse<Buffer>> {
+    const exportContent = await createBookLanguageDocumentationExport(options);
+    const html = createBookLanguageDocumentationPdfHtml({
+        markdown: exportContent.markdown,
+        language: exportContent.language,
+        logoDataUrl: await getPromptbookLogoDataUrl(),
+    });
+    const pdf = await renderHtmlToPdfOnServer(html);
+    return new NextResponse(pdf, {
+        headers: {
+            'Content-Type': 'application/pdf',
+            'Content-Disposition': 'attachment; filename="book-language-manual.pdf"',
+            'Content-Language': exportContent.language,
+            'Cache-Control': 'no-store, max-age=0',
+        },
+    });
+}
+/**
+ * Creates self-contained HTML for the Book language manual PDF renderer.
+ *
+ * @param options - Manual content, language, and inline branding assets.
+ * @returns Standalone printable HTML document.
+ */
+export function createBookLanguageDocumentationPdfHtml(
+    options: CreateBookLanguageDocumentationPdfHtmlOptions,
+): string {
+    const { markdown, language, logoDataUrl } = options;
+    const branding = getPromptbookExportBranding();
+    const documentHtml = groupHtmlHeadingSections(highlightBookCodeBlocksInHtml(renderMarkdown(markdown)));
+    return `<!doctype html>
+<html lang="${escapeHtml(language)}">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    ${createPromptbookBrandingMetaTags(branding)}
+    <title>${escapeHtml(branding.productName)} - Book Language Manual</title>
+    <style>${createBookLanguageDocumentationPdfStyles()}</style>
+</head>
+<body>
+    <main>
+        ${createPromptbookBrandingHeader(branding, logoDataUrl)}
+        ${documentHtml}
+        ${createPromptbookBrandingFooter(branding)}
+    </main>
+</body>
+</html>`;
+}
+/**
+ * Renders the Promptbook branding meta tags of the exported document.
+ *
+ * @param branding - Shared Promptbook export branding.
+ * @returns HTML meta tags describing the export.
+ *
+ * @private internal utility of Book language PDF export
+ */
+function createPromptbookBrandingMetaTags(branding: PromptbookExportBranding): string {
+    return spaceTrim(`
+        <meta name="application-name" content="${escapeHtml(branding.productName)}" />
+        <meta name="author" content="${escapeHtml(branding.productName)}" />
+        <meta name="generator" content="${escapeHtml(branding.creatorTool)}" />
+        <meta name="description" content="${escapeHtml(branding.metadataSummary)}" />
+        <meta name="keywords" content="${escapeHtml(branding.keywords.join(', '))}" />
+    `);
+}
+/**
+ * Renders the branded header shown above the manual title.
+ *
+ * @param branding - Shared Promptbook export branding.
+ * @param logoDataUrl - Inline Promptbook logo, or `null` when it is unavailable.
+ * @returns HTML header with the Promptbook mark and claim.
+ *
+ * @private internal utility of Book language PDF export
+ */
+function createPromptbookBrandingHeader(branding: PromptbookExportBranding, logoDataUrl: string | null): string {
+    const logoHtml = logoDataUrl
+        ? `<img class="manual-cover-logo" src="${escapeHtml(logoDataUrl)}" alt="${escapeHtml(
+              branding.productName,
+          )}" />`
+        : '';
+    return spaceTrim(`
+        <header class="manual-cover">
+            ${logoHtml}
+            <div>
+                <div class="manual-cover-product">${escapeHtml(branding.productName)}</div>
+                <p class="manual-cover-claim">${escapeHtml(branding.metadataSummary)}</p>
+            </div>
+        </header>
+    `);
+}
+/**
+ * Renders the branded footer closing the exported manual.
+ *
+ * @param branding - Shared Promptbook export branding.
+ * @returns HTML footer with Promptbook product details.
+ *
+ * @private internal utility of Book language PDF export
+ */
+function createPromptbookBrandingFooter(branding: PromptbookExportBranding): string {
+    const detailsHtml = branding.detailLines.length > 0 ? ` - ${escapeHtml(branding.detailLines.join(' • '))}` : '';
+    return `<footer class="manual-footer"><strong>${escapeHtml(branding.productName)}</strong>${detailsHtml}</footer>`;
+}

package/apps/agents-server/src/utils/bookLanguageDocumentation/createBookLanguageDocumentationPdfStyles.ts ADDED Viewed

@@ -0,0 +1,251 @@
+import { spaceTrim } from 'spacetrim';
+import { createBookSourceHighlightStyles } from '../../../../../src/book-components/BookEditor/createBookSourceHighlightStyles';
+import { PROMPTBOOK_COLOR } from '../../../../../src/config';
+import { darken } from '../../../../../src/utils/color/operators/darken';
+import { BOOK_SOURCE_PRE_CLASS_NAME } from './highlightBookCodeBlocksInHtml';
+/**
+ * How much the Promptbook color is darkened for text printed on white paper.
+ *
+ * The brand color itself is a light cyan, which is unreadable as ink.
+ *
+ * @private internal constant of `createBookLanguageDocumentationPdfStyles`
+ */
+const BRAND_INK_DARKEN_AMOUNT = 0.5;
+/**
+ * Creates the stylesheet of the standalone Book language manual PDF.
+ *
+ * The stylesheet intentionally uses no remote assets, so it stays deterministic
+ * in headless Chromium. Page breaking is driven by the sections created by
+ * `groupHtmlHeadingSections`.
+ *
+ * @returns CSS for the printable manual document.
+ */
+export function createBookLanguageDocumentationPdfStyles(): string {
+    const brandColor = PROMPTBOOK_COLOR.toHex();
+    const brandInkColor = PROMPTBOOK_COLOR.then(darken(BRAND_INK_DARKEN_AMOUNT)).toHex();
+    return spaceTrim(
+        (block) => `
+            @page {
+                size: A4;
+                margin: 16mm 14mm 18mm;
+            }
+            :root {
+                color: #172033;
+                font-family: Arial, Helvetica, sans-serif;
+                font-size: 10.5pt;
+                line-height: 1.52;
+            }
+            * {
+                box-sizing: border-box;
+            }
+            body {
+                margin: 0;
+                color: #172033;
+                background: #ffffff;
+            }
+            main {
+                max-width: 100%;
+            }
+            h1,
+            h2,
+            h3,
+            h4 {
+                color: #111827;
+                break-after: avoid;
+                page-break-after: avoid;
+            }
+            h1 {
+                margin: 0 0 0.8rem;
+                color: ${brandInkColor};
+                font-size: 26pt;
+                letter-spacing: -0.035em;
+                line-height: 1.15;
+            }
+            h2 {
+                margin: 0 0 0.75rem;
+                padding-bottom: 0.35rem;
+                border-bottom: 2px solid ${brandInkColor};
+                font-size: 17pt;
+                line-height: 1.25;
+            }
+            h3 {
+                margin: 1.5rem 0 0.45rem;
+                font-size: 13pt;
+                line-height: 1.3;
+            }
+            h4 {
+                margin: 1rem 0 0.35rem;
+                font-size: 11pt;
+            }
+            p,
+            ul,
+            ol,
+            blockquote,
+            pre,
+            table {
+                margin: 0 0 0.8rem;
+            }
+            p,
+            li,
+            blockquote {
+                orphans: 3;
+                widows: 3;
+            }
+            ul,
+            ol {
+                padding-left: 1.35rem;
+            }
+            li + li {
+                margin-top: 0.2rem;
+            }
+            a {
+                color: ${brandInkColor};
+                text-decoration: none;
+            }
+            code {
+                padding: 0.08rem 0.28rem;
+                border-radius: 0.2rem;
+                background: #eff6ff;
+                color: #1e3a8a;
+                font-family: "SFMono-Regular", Consolas, "Liberation Mono", monospace;
+                font-size: 0.9em;
+            }
+            pre {
+                overflow-wrap: anywhere;
+                padding: 0.85rem;
+                border: 1px solid #cbd5e1;
+                border-radius: 0.4rem;
+                background: #f8fafc;
+                color: #172033;
+                white-space: pre-wrap;
+                orphans: 3;
+                widows: 3;
+            }
+            pre code {
+                padding: 0;
+                background: transparent;
+                color: inherit;
+                font-size: 8.4pt;
+                line-height: 1.42;
+            }
+            pre.${BOOK_SOURCE_PRE_CLASS_NAME} {
+                border-color: ${brandColor}33;
+                background: #fbfcff;
+            }
+            ${block(createBookSourceHighlightStyles())}
+            blockquote {
+                margin-left: 0;
+                padding: 0.55rem 0.8rem;
+                border-left: 3px solid ${brandInkColor};
+                background: #eff6ff;
+                color: #334155;
+            }
+            table {
+                width: 100%;
+                border-collapse: collapse;
+            }
+            th,
+            td {
+                padding: 0.45rem;
+                border: 1px solid #cbd5e1;
+                text-align: left;
+                vertical-align: top;
+            }
+            th {
+                background: #f1f5f9;
+            }
+            thead {
+                display: table-header-group;
+            }
+            hr {
+                margin: 1.4rem 0;
+                border: 0;
+                border-top: 1px solid #cbd5e1;
+            }
+            .manual-cover {
+                display: flex;
+                align-items: center;
+                gap: 0.75rem;
+                margin-bottom: 1.4rem;
+                padding-bottom: 0.9rem;
+                border-bottom: 3px solid ${brandInkColor};
+                break-after: avoid;
+                page-break-after: avoid;
+            }
+            .manual-cover-logo {
+                width: 46px;
+                height: 46px;
+            }
+            .manual-cover-product {
+                color: ${brandInkColor};
+                font-size: 15pt;
+                font-weight: bold;
+                letter-spacing: -0.02em;
+            }
+            .manual-cover-claim {
+                margin: 0.1rem 0 0;
+                color: #475569;
+                font-size: 9pt;
+                line-height: 1.35;
+            }
+            .manual-chapter {
+                margin-top: 2.1rem;
+            }
+            .manual-section {
+                margin-top: 1.2rem;
+            }
+            .manual-subsection {
+                margin-top: 0.6rem;
+            }
+            .manual-footer {
+                margin-top: 1.6rem;
+                padding-top: 0.7rem;
+                border-top: 1px solid #cbd5e1;
+                color: #64748b;
+                font-size: 8.5pt;
+                break-inside: avoid;
+                page-break-inside: avoid;
+            }
+            .manual-footer strong {
+                color: ${brandInkColor};
+            }
+        `,
+    );
+}

package/apps/agents-server/src/utils/bookLanguageDocumentation/getBookLanguageDocumentationAgents.ts ADDED Viewed

@@ -0,0 +1,60 @@
+import { $provideAgentCollectionForServer } from '../../tools/$provideAgentCollectionForServer';
+import type {
+    BakedBookLanguageDocumentationAgent,
+    BookLanguageDocumentationAgentOption,
+} from './BookLanguageDocumentationAgent';
+/**
+ * Lists current server agents that can be selected in a Book language manual.
+ *
+ * @returns Agent identifiers and labels suitable for the export controls.
+ */
+export async function getBookLanguageDocumentationAgentOptions(): Promise<
+    ReadonlyArray<BookLanguageDocumentationAgentOption>
+> {
+    const collection = await $provideAgentCollectionForServer();
+    const agents = await collection.listAgents();
+    return agents.flatMap((agent) => {
+        if (!agent.permanentId) {
+            return [];
+        }
+        return [
+            {
+                id: agent.permanentId,
+                name: agent.agentName,
+            },
+        ];
+    });
+}
+/**
+ * Loads source text for the requested manual agents.
+ *
+ * Unknown identifiers are ignored. This keeps URLs created before an agent was
+ * deleted usable and prevents selected-agent controls from failing an export.
+ *
+ * @param selectedAgentIds - Agent identifiers selected by the export controls.
+ * @returns Current source snapshots ready for the core documentation generator.
+ */
+export async function getBakedBookLanguageDocumentationAgents(
+    selectedAgentIds: ReadonlyArray<string> | null,
+): Promise<ReadonlyArray<BakedBookLanguageDocumentationAgent>> {
+    const agentOptions = await getBookLanguageDocumentationAgentOptions();
+    const agentOptionById = new Map(agentOptions.map((agent) => [agent.id, agent]));
+    const selectedAgents =
+        selectedAgentIds === null
+            ? agentOptions
+            : selectedAgentIds
+                  .map((agentId) => agentOptionById.get(agentId))
+                  .filter((agent): agent is BookLanguageDocumentationAgentOption => agent !== undefined);
+    const collection = await $provideAgentCollectionForServer();
+    return Promise.all(
+        selectedAgents.map(async (agent) => ({
+            ...agent,
+            source: await collection.getAgentSource(agent.id),
+        })),
+    );
+}

package/apps/agents-server/src/utils/bookLanguageDocumentation/groupHtmlHeadingSections.ts ADDED Viewed

@@ -0,0 +1,77 @@
+/**
+ * Matches one heading element of the rendered manual.
+ *
+ * Headings always start a block in the rendered markdown, and code blocks keep
+ * their content HTML-escaped, so a raw heading tag can never appear inside one.
+ *
+ * @private internal constant of `groupHtmlHeadingSections`
+ */
+const HTML_HEADING_REGEX = /<h([1-6])\b[^>]*>[\s\S]*?<\/h\1>/g;
+/**
+ * Class names applied to grouped sections, indexed by heading level.
+ *
+ * Grouping the flat markdown output into nested sections is what makes page
+ * breaking controllable - CSS can then keep a heading together with the content
+ * that belongs to it instead of breaking wherever a page happens to end.
+ */
+export const HTML_HEADING_SECTION_CLASS_NAMES: Readonly<Record<number, string>> = {
+    1: 'manual-part',
+    2: 'manual-chapter',
+    3: 'manual-section',
+    4: 'manual-subsection',
+    5: 'manual-subsection',
+    6: 'manual-subsection',
+};
+/**
+ * Wraps every heading and the content below it into one nested `<section>`.
+ *
+ * @param html - Flat HTML produced from the manual markdown.
+ * @returns HTML where each heading owns a section element.
+ */
+export function groupHtmlHeadingSections(html: string): string {
+    HTML_HEADING_REGEX.lastIndex = 0;
+    const openSectionLevels: Array<number> = [];
+    let groupedHtml = '';
+    let contentStartIndex = 0;
+    let headingMatch: RegExpExecArray | null;
+    while ((headingMatch = HTML_HEADING_REGEX.exec(html)) !== null) {
+        const headingLevel = Number(headingMatch[1]);
+        groupedHtml += html.slice(contentStartIndex, headingMatch.index);
+        groupedHtml += closeSectionsFromLevel(openSectionLevels, headingLevel);
+        groupedHtml += `<section class="${HTML_HEADING_SECTION_CLASS_NAMES[headingLevel]}">`;
+        groupedHtml += headingMatch[0];
+        openSectionLevels.push(headingLevel);
+        contentStartIndex = headingMatch.index + headingMatch[0].length;
+    }
+    groupedHtml += html.slice(contentStartIndex);
+    groupedHtml += closeSectionsFromLevel(openSectionLevels, 1);
+    return groupedHtml;
+}
+/**
+ * Closes every open section that cannot contain the upcoming heading.
+ *
+ * @param openSectionLevels - Heading levels of the currently open sections, mutated in place.
+ * @param headingLevel - Heading level that is about to be opened.
+ * @returns Closing tags for the sections that had to end.
+ *
+ * @private internal utility of `groupHtmlHeadingSections`
+ */
+function closeSectionsFromLevel(openSectionLevels: Array<number>, headingLevel: number): string {
+    let closingTags = '';
+    while (openSectionLevels.length > 0 && openSectionLevels[openSectionLevels.length - 1]! >= headingLevel) {
+        openSectionLevels.pop();
+        closingTags += '</section>';
+    }
+    return closingTags;
+}

package/apps/agents-server/src/utils/bookLanguageDocumentation/highlightBookCodeBlocksInHtml.ts ADDED Viewed

@@ -0,0 +1,68 @@
+import { highlightBookSourceToHtml } from '../../../../../src/book-components/BookEditor/highlightBookSourceToHtml';
+/**
+ * Matches one fenced code block rendered by the markdown renderer.
+ *
+ * @private internal constant of `highlightBookCodeBlocksInHtml`
+ */
+const RENDERED_CODE_BLOCK_REGEX = /<pre><code class="([^"]*)">([\s\S]*?)<\/code><\/pre>/g;
+/**
+ * Info-string language marking a Book source code block.
+ *
+ * @private internal constant of `highlightBookCodeBlocksInHtml`
+ */
+const BOOK_CODE_BLOCK_LANGUAGE_CLASS_NAME = 'language-book';
+/**
+ * Class name marking a `<pre>` that contains highlighted Book source.
+ */
+export const BOOK_SOURCE_PRE_CLASS_NAME = 'book-source';
+/**
+ * HTML entities produced while rendering markdown code blocks.
+ *
+ * @private internal constant of `highlightBookCodeBlocksInHtml`
+ */
+const RENDERED_HTML_ENTITIES: Readonly<Record<string, string>> = {
+    '&amp;': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&#39;': "'",
+};
+/**
+ * Replaces every rendered ```book code block with syntax-highlighted markup.
+ *
+ * The highlighting itself is done by `highlightBookSourceToHtml`, which shares
+ * its tokens and colors with `<BookEditor/>`.
+ *
+ * @param html - HTML produced from the manual markdown.
+ * @returns HTML where Book sources are syntax highlighted.
+ */
+export function highlightBookCodeBlocksInHtml(html: string): string {
+    RENDERED_CODE_BLOCK_REGEX.lastIndex = 0;
+    return html.replace(RENDERED_CODE_BLOCK_REGEX, (match, className: string, renderedSource: string) => {
+        if (!className.split(/\s+/).includes(BOOK_CODE_BLOCK_LANGUAGE_CLASS_NAME)) {
+            return match;
+        }
+        const bookSource = decodeRenderedHtmlEntities(renderedSource).replace(/\n$/, '');
+        return `<pre class="${BOOK_SOURCE_PRE_CLASS_NAME}"><code>${highlightBookSourceToHtml(bookSource)}</code></pre>`;
+    });
+}
+/**
+ * Restores the raw Book source from a rendered markdown code block.
+ *
+ * @param renderedSource - HTML-escaped code block content.
+ * @returns Original Book source text.
+ *
+ * @private internal utility of `highlightBookCodeBlocksInHtml`
+ */
+function decodeRenderedHtmlEntities(renderedSource: string): string {
+    return renderedSource.replace(/&(?:amp|lt|gt|quot|#39);/g, (entity) => RENDERED_HTML_ENTITIES[entity] || entity);
+}

package/apps/agents-server/src/utils/buildDomainTablePrefix.ts ADDED Viewed

@@ -0,0 +1,24 @@
+/**
+ * Builds the deterministic per-server table prefix from a normalized domain.
+ *
+ * The prefix doubles as the stable namespace key of one server:
+ * - In Supabase mode it prefixes the server tables inside the shared database.
+ * - In standalone SQLite mode it selects the isolated per-server database file.
+ *
+ * Note: Keep in sync with `build_domain_table_prefix` in `install.sh`.
+ *
+ * @param domain - Normalized server domain such as `client.example.com`.
+ * @returns Prefix such as `server_client_example_com_`.
+ */
+export function buildDomainTablePrefix(domain: string): string {
+    const prefixSuffix = domain
+        .toLowerCase()
+        .replace(/-/gu, '_dash_')
+        .replace(/\./gu, '_')
+        .replace(/:/gu, '_port_')
+        .replace(/[^a-z0-9_]/gu, '_')
+        .replace(/_+/gu, '_')
+        .replace(/^_+|_+$/gu, '');
+    return `server_${prefixSuffix}_`;
+}