@protoyard/blueprint 0.0.0-stage → 1.1.1

package/dist/brief/content-synthesize.d.ts

@@ -0,0 +1,31 @@
+import type { ContentKind } from '../kinds/kind.ts';
+import type { BriefKindDetection } from './kind-detection.ts';
+/** Longer briefs are cut here (same cap as app synthesis). */
+export declare const MAX_CONTENT_BRIEF_LENGTH = 5000;
+export interface ContentBriefOptions {
+    /** Product / document name; default: a fictional name from the brief. */
+    name?: string;
+}
+export interface ContentBriefResult {
+    kind: ContentKind;
+    kindDetection: BriefKindDetection;
+    /** Outline family id (generic until richer templates ship). */
+    outline: string;
+    /**
+     * Draft content blueprint as plain JSON (formatVersion, name, kind, body).
+     * Not validated against engine body schemas until those are wired.
+     */
+    json: Record<string, unknown>;
+    rationale: string[];
+}
+/**
+ * Deck brief → outline templates (pitch/QBR/…) + deterministic layout selection.
+ * Free-slide blocks stay as draft scaffolding; catalog layouts get minimal props
+ * from the slide title when selection leaves `free`.
+ */
+export declare function synthesizeDeckFromBrief(brief: string, detection: BriefKindDetection, options?: ContentBriefOptions): ContentBriefResult;
+/** Page outlines (landing, pricing, waitlist, generic) with bounded blocks. */
+export declare function synthesizePageFromBrief(brief: string, detection: BriefKindDetection, options?: ContentBriefOptions): ContentBriefResult;
+/** Doc outlines (report, handbook, one-pager, proposal, generic) with bounded blocks. */
+export declare function synthesizeDocFromBrief(brief: string, detection: BriefKindDetection, options?: ContentBriefOptions): ContentBriefResult;
+export declare function synthesizeContentFromBrief(kind: ContentKind, brief: string, detection: BriefKindDetection, options?: ContentBriefOptions): ContentBriefResult;

package/dist/brief/content-synthesize.js

@@ -0,0 +1,210 @@
+/**
+ * Kind-specific brief synthesizers for deck, page and doc (ADR-036).
+ * Called by `blueprintFromBrief` after kind detection, before any app
+ * archetype scoring. Output is honest draft scaffolding: stable ids, no
+ * fabricated facts. Page and doc section outlines live in `page-doc-outlines.ts`.
+ */
+import { hashString } from '@protoyard/core';
+import { propsForSelectedLayout, selectDeckLayouts } from "../authoring/select-deck-layouts.js";
+import { synthesizeDeckOutline } from "./deck-outlines.js";
+import { docBodyFromOutline, draftSlugId, pageBodyFromOutline } from "./draft-bodies.js";
+import { applyOutlineBounds, boundBriefInput, MAX_CONTENT_BRIEF_LENGTH as CONTENT_CAP, } from "./limits.js";
+import { buildDocOutline, buildPageOutline } from "./page-doc-outlines.js";
+import { normalize, titleCase } from "./text.js";
+/** Longer briefs are cut here (same cap as app synthesis). */
+export const MAX_CONTENT_BRIEF_LENGTH = CONTENT_CAP;
+const NAME_WORDS = [
+    'Harbor',
+    'Lumen',
+    'Cedar',
+    'Beacon',
+    'Juniper',
+    'Copper',
+    'Willow',
+    'Lantern',
+    'Meadow',
+    'Summit',
+    'Quarry',
+    'Tidal',
+    'Ember',
+    'Orchard',
+    'Kestrel',
+    'Maple',
+];
+function pickName(source, kind, forced) {
+    if (forced?.trim())
+        return forced.trim().slice(0, 80);
+    const normalized = normalize(source);
+    const word = NAME_WORDS[hashString(normalized || kind) % NAME_WORDS.length];
+    const label = kind === 'deck' ? 'Deck' : kind === 'page' ? 'Page' : 'Doc';
+    return `${word} ${label}`.slice(0, 80);
+}
+function brandSeed(name) {
+    const seeds = [
+        '#0284c7',
+        '#059669',
+        '#0f766e',
+        '#1d4ed8',
+        '#4338ca',
+        '#7c3aed',
+        '#b45309',
+        '#be123c',
+    ];
+    return seeds[hashString(name) % seeds.length];
+}
+function base(kind, name, description) {
+    return {
+        formatVersion: 1,
+        name,
+        description: description || `${titleCase(kind)} draft.`,
+        tags: [kind],
+        brand: {
+            name: name.slice(0, 40),
+            seed: brandSeed(name),
+            styleProfile: 'soft',
+            font: 'humanist',
+        },
+        kind,
+    };
+}
+/**
+ * Deck brief → outline templates (pitch/QBR/…) + deterministic layout selection.
+ * Free-slide blocks stay as draft scaffolding; catalog layouts get minimal props
+ * from the slide title when selection leaves `free`.
+ */
+export function synthesizeDeckFromBrief(brief, detection, options = {}) {
+    const bound = boundBriefInput(brief, { maxLength: MAX_CONTENT_BRIEF_LENGTH });
+    const source = bound.brief;
+    const name = pickName(source, 'deck', options.name);
+    const outline = synthesizeDeckOutline(source, {
+        title: options.name?.trim() ? options.name.trim().slice(0, 80) : undefined,
+    });
+    const selections = selectDeckLayouts(outline.plan.map((slide, index) => {
+        const body = outline.deck.slides[index];
+        const blockTypes = body && Array.isArray(body.blocks)
+            ? body.blocks
+                .map((block) => block && typeof block === 'object' && 'type' in block
+                ? String(block.type)
+                : '')
+                .filter(Boolean)
+            : [];
+        return {
+            id: slide.id,
+            role: slide.role,
+            pacing: slide.pacing,
+            purpose: slide.purpose,
+            blockTypes,
+        };
+    }), { aspect: outline.deck.aspect });
+    const slides = outline.deck.slides.map((slide, index) => {
+        const choice = selections[index];
+        const layout = choice?.layout ?? 'free';
+        if (layout === 'free') {
+            return slide;
+        }
+        return {
+            id: slide.id,
+            title: slide.title,
+            layout,
+            props: propsForSelectedLayout(layout, { title: slide.title, purpose: slide.notes }),
+            notes: slide.notes,
+        };
+    });
+    const rationale = [
+        detection.reason,
+        ...bound.notices,
+        ...outline.rationale,
+        ...selections.map((row) => `${row.id}: ${row.rationale}`),
+        'Slide bodies are draft placeholders — no fabricated facts.',
+    ];
+    return {
+        kind: 'deck',
+        kindDetection: detection,
+        outline: outline.outline,
+        rationale,
+        json: {
+            ...base('deck', name, outline.deck.title.slice(0, 280)),
+            // DeckBodySchema is DeckSchema: style + slides only (no title/aspect keys).
+            deck: {
+                style: { aspect: outline.deck.aspect },
+                slides,
+            },
+        },
+    };
+}
+/** Page outlines (landing, pricing, waitlist, generic) with bounded blocks. */
+export function synthesizePageFromBrief(brief, detection, options = {}) {
+    const bound = boundBriefInput(brief, { maxLength: MAX_CONTENT_BRIEF_LENGTH });
+    const source = bound.brief;
+    const built = buildPageOutline(source, { title: options.name });
+    const clipped = applyOutlineBounds({
+        kind: 'page',
+        title: built.title,
+        sections: built.sections,
+    });
+    const title = (clipped.outline.title ?? built.title).slice(0, 120);
+    const name = options.name?.trim()
+        ? options.name.trim().slice(0, 80)
+        : pickName(source, 'page', title);
+    const rationale = [detection.reason, ...bound.notices, ...clipped.notices, ...built.rationale];
+    const sections = (clipped.outline.sections ?? built.sections);
+    const page = pageBodyFromOutline({
+        id: draftSlugId(name, 'page-draft'),
+        title,
+        description: title,
+        sections,
+    });
+    return {
+        kind: 'page',
+        kindDetection: detection,
+        outline: built.outline,
+        rationale,
+        json: {
+            ...base('page', name, title.slice(0, 280)),
+            page,
+        },
+    };
+}
+/** Doc outlines (report, handbook, one-pager, proposal, generic) with bounded blocks. */
+export function synthesizeDocFromBrief(brief, detection, options = {}) {
+    const bound = boundBriefInput(brief, { maxLength: MAX_CONTENT_BRIEF_LENGTH });
+    const source = bound.brief;
+    const built = buildDocOutline(source, { title: options.name });
+    const clipped = applyOutlineBounds({
+        kind: 'doc',
+        title: built.title,
+        sections: built.sections,
+    });
+    const title = (clipped.outline.title ?? built.title).slice(0, 120);
+    const name = options.name?.trim()
+        ? options.name.trim().slice(0, 80)
+        : pickName(source, 'doc', title);
+    const rationale = [detection.reason, ...bound.notices, ...clipped.notices, ...built.rationale];
+    const sections = (clipped.outline.sections ?? built.sections);
+    const doc = docBodyFromOutline({
+        id: draftSlugId(name, 'doc-draft'),
+        title,
+        description: title,
+        sections,
+    });
+    return {
+        kind: 'doc',
+        kindDetection: detection,
+        outline: built.outline,
+        rationale,
+        json: {
+            ...base('doc', name, title.slice(0, 280)),
+            doc,
+        },
+    };
+}
+export function synthesizeContentFromBrief(kind, brief, detection, options = {}) {
+    switch (kind) {
+        case 'deck':
+            return synthesizeDeckFromBrief(brief, detection, options);
+        case 'page':
+            return synthesizePageFromBrief(brief, detection, options);
+        case 'doc':
+            return synthesizeDocFromBrief(brief, detection, options);
+    }
+}

package/dist/brief/deck-outlines.d.ts

@@ -0,0 +1,96 @@
+export declare const DECK_OUTLINE_IDS: readonly ["pitch", "qbr", "launch", "status", "training", "lesson", "report", "talk"];
+export type DeckOutlineId = (typeof DECK_OUTLINE_IDS)[number];
+/** How long a slide holds the room (A punch, B idea, C diagram, D story). */
+export type DeckPacing = 'punch' | 'idea' | 'diagram' | 'story';
+/** Caps for synthesized outlines (far inside the deck schema's own limits). */
+export declare const DECK_OUTLINE_LIMITS: Readonly<{
+    /** No template has more slides than this. */
+    maxSlides: 16;
+    /** Title text taken from the brief. */
+    titleLength: 80;
+    /** Characters of the brief read when picking a template. */
+    briefLength: 5000;
+}>;
+/** The block builders a template slide can use. */
+type SlideBody = 'title' | 'agenda' | 'statement' | 'bullets' | 'checklist' | 'metrics' | 'chart-note' | 'steps' | 'timeline' | 'comparison' | 'cards' | 'quote' | 'people' | 'risk' | 'poll' | 'quiz' | 'close';
+interface TemplateSlide {
+    /** Stable id suffix: the slide id is `slide-<key>`. */
+    key: string;
+    /** Semantic role, read by layout selection. */
+    role: string;
+    pacing: DeckPacing;
+    title: string;
+    body: SlideBody;
+    /** What the author should put here (also the speaker-note guidance). */
+    purpose: string;
+    /** Core slides are always included; optional ones fill a requested count. */
+    core: boolean;
+}
+interface DeckOutlineTemplate {
+    id: DeckOutlineId;
+    label: string;
+    /** Whole-word phrases in the brief that select this template. */
+    cues: readonly string[];
+    slides: readonly TemplateSlide[];
+}
+export declare const DECK_OUTLINES: readonly DeckOutlineTemplate[];
+/** A slide count the brief asks for: "12 slides", "ten-slide", "a 15-minute talk" (one slide a minute). */
+export declare function requestedSlideCount(brief: string): number | null;
+/** The template a brief asks for, with the cues that matched (longest phrase wins ties). */
+export declare function chooseDeckOutline(brief: string): {
+    id: DeckOutlineId;
+    cues: string[];
+};
+/** A deck title from the brief: the topic after "about/on/for", else the first sentence. */
+export declare function deckTitleFromBrief(brief: string, fallback?: string): string;
+/** Plain JSON blocks; the test validates every one with `@protoyard/blocks`. */
+type BlockJson = Record<string, unknown>;
+export interface DeckOutlineOptions {
+    /** Use this template instead of reading cues from the brief. */
+    outline?: DeckOutlineId;
+    /** Slide count; overrides a count read from the brief. Clamped to the template. */
+    slides?: number;
+    /** Deck title; default: the topic of the brief. */
+    title?: string;
+}
+/** One slide of the synthesized deck body: a free slide of blocks. */
+export interface DeckOutlineSlide {
+    id: string;
+    title: string;
+    layout: 'free';
+    blocks: BlockJson[];
+    notes: string;
+}
+/** Per-slide data for layout selection and lint. */
+export interface DeckSlidePlan {
+    id: string;
+    role: string;
+    pacing: DeckPacing;
+    purpose: string;
+    core: boolean;
+}
+export interface DeckOutlineResult {
+    outline: DeckOutlineId;
+    label: string;
+    /** The deck body (the blueprint's `deck` key). */
+    deck: {
+        title: string;
+        aspect: '16:9';
+        slides: DeckOutlineSlide[];
+    };
+    plan: DeckSlidePlan[];
+    rationale: string[];
+    /** The count asked for (options or brief), before clamping; null when none. */
+    requestedSlides: number | null;
+}
+/** The slide-count range a template supports: its core slides up to all slides. */
+export declare function deckOutlineRange(id: DeckOutlineId): {
+    min: number;
+    max: number;
+};
+/**
+ * Builds a draft deck outline from a brief. Pure and deterministic: the same
+ * brief and options give the same slide ids, order, blocks and rationale.
+ */
+export declare function synthesizeDeckOutline(brief: string, options?: DeckOutlineOptions): DeckOutlineResult;
+export {};