@vertesia/build-tools 1.0.0-dev.20260225.024852Z → 1.0.0-dev.20260227.104700Z

package/lib/build-tools.js

@@ -717,6 +717,228 @@ const skillCollectionTransformer = {
     }
 };
 
+/**
+ * Utilities for discovering asset files in template directories
+ */
+/**
+ * Files to exclude from template asset discovery
+ * (source files and the template definition itself)
+ */
+const EXCLUDED_PATTERNS = [
+    /^TEMPLATE\.md$/,
+    /\.ts$/,
+    /\.js$/,
+];
+function isExcluded(fileName) {
+    return EXCLUDED_PATTERNS.some(p => p.test(fileName));
+}
+/**
+ * Discover asset files in a template directory.
+ * All files except TEMPLATE.md, *.ts, and *.js are considered assets.
+ *
+ * @param templateFilePath - Absolute path to the TEMPLATE.md file
+ * @param templatePath - The template path segment (e.g., "examples/report")
+ * @returns Discovered assets and metadata
+ */
+function discoverTemplateAssets(templateFilePath, templatePath) {
+    const templateDir = path.dirname(templateFilePath);
+    const fileNames = [];
+    const assetFiles = [];
+    let files;
+    try {
+        files = readdirSync(templateDir).filter(file => {
+            try {
+                return statSync(path.join(templateDir, file)).isFile();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        files = [];
+    }
+    for (const file of files) {
+        if (isExcluded(file)) {
+            continue;
+        }
+        fileNames.push(file);
+        assetFiles.push({
+            sourcePath: path.join(templateDir, file),
+            destPath: path.join('templates', templatePath, file),
+            type: 'template',
+        });
+    }
+    return { fileNames, assetFiles };
+}
+
+/**
+ * Template transformer preset for markdown files with frontmatter
+ */
+/**
+ * Zod schema for template frontmatter validation.
+ * Only includes fields authored by the user.
+ * The name and id are inferred from the directory structure.
+ */
+const TemplateFrontmatterSchema = z.object({
+    title: z.string().optional(),
+    description: z.string().min(1, 'Template description is required'),
+    tags: z.array(z.string()).optional(),
+    type: z.enum(['presentation', 'document']),
+}).strict();
+/**
+ * MUST be kept in sync with @vertesia/tools-sdk RenderingTemplateDefinition
+ * Zod schema for template definition
+ */
+const RenderingTemplateDefinitionSchema = z.object({
+    id: z.string().min(1, 'Template id is required'),
+    name: z.string().min(1, 'Template name is required'),
+    title: z.string().optional(),
+    description: z.string().min(1, 'Template description is required'),
+    instructions: z.string(),
+    tags: z.array(z.string()).optional(),
+    type: z.enum(['presentation', 'document']),
+    assets: z.array(z.string()),
+}).passthrough();
+/**
+ * Derive the template path segments from the file path.
+ *
+ * Example: .../templates/examples/report/TEMPLATE.md
+ *   → category: "examples", name: "report", relative: "examples/report"
+ */
+function deriveTemplatePathInfo(filePath) {
+    const templateDir = path.dirname(filePath);
+    const templateName = path.basename(templateDir);
+    const collectionDir = path.dirname(templateDir);
+    const category = path.basename(collectionDir);
+    return { category, templateName, relative: `${category}/${templateName}` };
+}
+/**
+ * Template transformer preset
+ * Transforms markdown files with ?template suffix OR TEMPLATE.md files into template definition objects
+ *
+ * Matches:
+ * - Files with ?template suffix: ./my-template.md?template
+ * - TEMPLATE.md files: ./my-template/TEMPLATE.md
+ *
+ * @example
+ * ```typescript
+ * import template1 from './my-template.md?template';
+ * import template2 from './my-template/TEMPLATE.md';
+ * // Both are RenderingTemplateDefinition objects
+ * ```
+ */
+const templateTransformer = {
+    pattern: /(\.md\?template$|\/TEMPLATE\.md$)/,
+    schema: RenderingTemplateDefinitionSchema,
+    transform: (content, filePath) => {
+        const { frontmatter, content: markdown } = parseFrontmatter(content);
+        // Validate frontmatter
+        const frontmatterValidation = TemplateFrontmatterSchema.safeParse(frontmatter);
+        if (!frontmatterValidation.success) {
+            const errors = frontmatterValidation.error.errors
+                .map((err) => {
+                const pathStr = err.path.length > 0 ? err.path.join('.') : 'frontmatter';
+                return `  - ${pathStr}: ${err.message}`;
+            })
+                .join('\n');
+            throw new Error(`Invalid frontmatter in ${filePath}:\n${errors}`);
+        }
+        // Derive template path from directory structure
+        const { category, templateName, relative: templatePath } = deriveTemplatePathInfo(filePath);
+        // Discover asset files in the template directory
+        const assets = discoverTemplateAssets(filePath, templatePath);
+        // Build template definition
+        // Assets use absolute paths for direct server-side resolution
+        const templateData = {
+            id: `${category}:${templateName}`,
+            name: templateName,
+            title: frontmatter.title,
+            description: frontmatter.description,
+            instructions: markdown,
+            tags: frontmatter.tags,
+            type: frontmatter.type,
+            assets: assets.fileNames.map(f => `/templates/${templatePath}/${f}`),
+        };
+        return {
+            data: templateData,
+            assets: assets.assetFiles,
+        };
+    }
+};
+
+/**
+ * Template collection transformer for directory-based template imports
+ * Scans a directory for subdirectories containing TEMPLATE.md files
+ */
+/**
+ * Template collection transformer preset
+ * Transforms directory imports with ?templates suffix into an array of template imports
+ *
+ * Matches:
+ * - ./all?templates (recommended - generates all.js in the directory)
+ * - Any path ending with a filename and ?templates
+ *
+ * NOTE: A filename before ?templates is REQUIRED to avoid naming conflicts.
+ * The filename becomes the output module name.
+ *
+ * @example
+ * ```typescript
+ * import templates from './all?templates';
+ * // Scans current directory for subdirectories with TEMPLATE.md
+ * // Generates all.js containing array of all templates
+ * ```
+ */
+const templateCollectionTransformer = {
+    pattern: /\/[^/?]+\?templates$/,
+    virtual: true,
+    transform: (_content, filePath) => {
+        // Remove ?templates suffix and the filename to get directory path
+        const pathWithoutQuery = filePath.replace(/\?templates$/, '');
+        const dirPath = path.dirname(pathWithoutQuery);
+        if (!existsSync(dirPath)) {
+            throw new Error(`Directory not found: ${dirPath}`);
+        }
+        if (!statSync(dirPath).isDirectory()) {
+            throw new Error(`Not a directory: ${dirPath}`);
+        }
+        // Scan for subdirectories containing TEMPLATE.md
+        const entries = readdirSync(dirPath);
+        const imports = [];
+        const names = [];
+        for (const entry of entries) {
+            const entryPath = path.join(dirPath, entry);
+            try {
+                if (statSync(entryPath).isDirectory()) {
+                    const templateFile = path.join(entryPath, 'TEMPLATE.md');
+                    if (existsSync(templateFile)) {
+                        const identifier = `Template_${entry.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+                        imports.push(`import ${identifier} from './${entry}/TEMPLATE.md';`);
+                        names.push(identifier);
+                    }
+                }
+            }
+            catch (_err) {
+                // Skip entries that can't be read
+                continue;
+            }
+        }
+        if (names.length === 0) {
+            console.warn(`No TEMPLATE.md files found in subdirectories of ${dirPath}`);
+        }
+        // Generate code that imports all templates and exports as array
+        const code = [
+            ...imports,
+            '',
+            `export default [${names.join(', ')}];`
+        ].join('\n');
+        return {
+            data: null,
+            code
+        };
+    }
+};
+
 /**
  * Raw transformer preset for importing file content as strings
  */
@@ -1794,5 +2016,5 @@ const promptTransformer = {
     }
 };
 
-export { PromptDefinitionSchema, PromptRole, SkillDefinitionSchema, SkillPropertiesSchema, TemplateType, parseFrontmatter, promptTransformer, rawTransformer, skillCollectionTransformer, skillTransformer, vertesiaImportPlugin };
+export { PromptDefinitionSchema, PromptRole, RenderingTemplateDefinitionSchema, SkillDefinitionSchema, SkillPropertiesSchema, TemplateType, parseFrontmatter, promptTransformer, rawTransformer, skillCollectionTransformer, skillTransformer, templateCollectionTransformer, templateTransformer, vertesiaImportPlugin };
 //# sourceMappingURL=build-tools.js.map