@vertesia/build-tools 1.2.0 → 1.4.0-dev.20260614.160504Z

package/src/plugin.ts

@@ -1,166 +0,0 @@
-/**
- * Core Rollup plugin implementation for transforming imports
- */
-
-import type { Plugin } from 'rollup';
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import type { PluginConfig, TransformerRule, AssetFile } from './types.js';
-import { copyAssets } from './utils/asset-copy.js';
-import { compileWidgets } from './utils/widget-compiler.js';
-import type { WidgetMetadata } from './utils/asset-discovery.js';
-
-/**
- * Creates a Rollup plugin that transforms imports based on configured rules
- */
-export function vertesiaImportPlugin(config: PluginConfig): Plugin {
-    const { transformers, assetsDir = './dist', widgetConfig } = config;
-
-    if (!transformers || transformers.length === 0) {
-        throw new Error('vertesiaImportPlugin: At least one transformer must be configured');
-    }
-
-    // Track assets to copy and widgets to compile
-    const assetsToProcess: AssetFile[] = [];
-    const widgetsToCompile: WidgetMetadata[] = [];
-    const shouldCopyAssets = assetsDir !== false;
-    const shouldCompileWidgets = widgetConfig !== undefined && assetsDir !== false;
-
-    return {
-        name: 'vertesia-import-plugin',
-
-        /**
-         * Resolve import IDs to handle pattern-based imports
-         */
-        resolveId(source: string, importer: string | undefined) {
-            // Check if any transformer pattern matches
-            for (const transformer of transformers) {
-                if (transformer.pattern.test(source)) {
-                    // Handle relative imports
-                    if (source.startsWith('.') && importer) {
-                        const cleanSource = source.replace(transformer.pattern, '');
-                        // Strip query parameters from importer to get the file path
-                        const cleanImporter = importer.indexOf('?') >= 0
-                            ? importer.substring(0, importer.indexOf('?'))
-                            : importer;
-                        // Always use dirname to get the directory containing the importer
-                        const baseDir = path.dirname(cleanImporter);
-                        const resolved = path.resolve(baseDir, cleanSource);
-                        // Return with the pattern suffix to identify it in load
-                        const suffix = source.match(transformer.pattern)?.[0] || '';
-                        return resolved + suffix;
-                    }
-                    return source;
-                }
-            }
-            return null; // Let other plugins handle it
-        },
-
-        /**
-         * Load and transform the file content
-         */
-        async load(id: string) {
-            // Find matching transformer
-            let matchedTransformer: TransformerRule | undefined;
-            let cleanId = id;
-
-            for (const transformer of transformers) {
-                if (transformer.pattern.test(id)) {
-                    matchedTransformer = transformer;
-                    // Remove query parameters to get actual file path
-                    // For example: '/path/file.md?skill' -> '/path/file.md'
-                    //              '/path/file.html?raw' -> '/path/file.html'
-                    const queryIndex = id.indexOf('?');
-                    cleanId = queryIndex >= 0 ? id.substring(0, queryIndex) : id;
-                    break;
-                }
-            }
-
-            if (!matchedTransformer) {
-                return null; // Not for us
-            }
-
-            try {
-                // Read file content (skip for virtual transforms)
-                const content = matchedTransformer.virtual
-                    ? ''
-                    : readFileSync(cleanId, 'utf-8');
-
-                // Transform the content
-                const result = await matchedTransformer.transform(content, cleanId);
-
-                // Collect assets if any
-                if (result.assets && shouldCopyAssets) {
-                    assetsToProcess.push(...result.assets);
-                }
-
-                // Collect widgets if any
-                if (result.widgets && shouldCompileWidgets) {
-                    widgetsToCompile.push(...result.widgets);
-                }
-
-                // Validate if schema provided
-                if (matchedTransformer.schema) {
-                    const validation = matchedTransformer.schema.safeParse(result.data);
-                    if (!validation.success) {
-                        const errors = validation.error.errors
-                            .map((err) => `  - ${err.path.join('.')}: ${err.message}`)
-                            .join('\n');
-                        throw new Error(
-                            `Validation failed for ${id}:\n${errors}`
-                        );
-                    }
-                }
-
-                // Generate code
-                const imports = result.imports ? result.imports.join('\n') + '\n\n' : '';
-                if (result.code) {
-                    // Custom code provided - prepend imports
-                    return imports + result.code;
-                } else {
-                    // Default: export data (escape if string, otherwise stringify as JSON)
-                    const dataJson = JSON.stringify(result.data, null, 2);
-                    return `${imports}export default ${dataJson};`;
-                }
-            } catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                this.error(`Failed to transform ${id}: ${message}`);
-            }
-        },
-
-        /**
-         * Copy assets and compile widgets after all modules are loaded
-         */
-        async buildEnd() {
-            // Copy script assets
-            if (shouldCopyAssets && assetsToProcess.length > 0) {
-                try {
-                    const copied = copyAssets(assetsToProcess, assetsDir as string);
-                    console.log(`Copied ${copied} asset file(s) to ${assetsDir}`);
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    this.warn(`Failed to copy assets: ${message}`);
-                }
-            }
-
-            // Compile widgets
-            if (shouldCompileWidgets && widgetsToCompile.length > 0) {
-                try {
-                    const widgetsDir = config.widgetsDir || 'widgets';
-                    const outputDir = path.join(assetsDir as string, widgetsDir);
-
-                    console.log(`Compiling ${widgetsToCompile.length} widget(s)...`);
-                    const compiled = await compileWidgets(
-                        widgetsToCompile,
-                        outputDir,
-                        widgetConfig
-                    );
-                    console.log(`Compiled ${compiled} widget(s) to ${outputDir}`);
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    this.error(`Failed to compile widgets: ${message}`);
-                }
-            }
-        }
-    };
-}

package/src/presets/index.ts

@@ -1,10 +0,0 @@
-/**
- * Preset transformers for common use cases
- */
-
-export { skillTransformer, SkillDefinitionSchema, SkillPropertiesSchema, type SkillDefinition, type SkillContentType } from './skill.js';
-export { skillCollectionTransformer } from './skill-collection.js';
-export { templateTransformer, RenderingTemplateDefinitionSchema, type RenderingTemplateDefinition } from './template.js';
-export { templateCollectionTransformer } from './template-collection.js';
-export { rawTransformer } from './raw.js';
-export { promptTransformer, PromptDefinitionSchema, type PromptDefinition, type PromptContentType, PromptRole, TemplateType } from './prompt.js';

package/src/types.ts

@@ -1,140 +0,0 @@
-/**
- * Type definitions for the Vertesia Rollup Import Plugin
- */
-
-import type { Plugin } from 'rollup';
-import type { z } from 'zod';
-
-/**
- * Asset file to be copied during build
- */
-export interface AssetFile {
-    /** Source file path (absolute) */
-    sourcePath: string;
-
-    /** Relative destination path within assets directory */
-    destPath: string;
-
-    /** Asset type for categorization */
-    type: 'script' | 'template';
-}
-
-/**
- * Result of a transform function
- */
-export interface TransformResult {
-    /** The data to export (can be text or JSON object) */
-    data: unknown;
-
-    /** Optional: additional imports to inject at the top of the generated module */
-    imports?: string[];
-
-    /** Optional: custom code to generate instead of default JSON export */
-    code?: string;
-
-    /** Optional: additional asset files to copy */
-    assets?: AssetFile[];
-
-    /** Optional: widget metadata for compilation */
-    widgets?: Array<{ name: string; path: string }>;
-}
-
-/**
- * Transform function that converts file content into exportable data
- */
-export type TransformFunction = (
-    content: string,
-    filePath: string
-) => TransformResult | Promise<TransformResult>;
-
-/**
- * Configuration for a single import transformer rule
- */
-export interface TransformerRule {
-    /** Pattern to match import paths (e.g., /\.md\?skill$/ or /\?raw$/) */
-    pattern: RegExp;
-
-    /** Transform function to convert file content */
-    transform: TransformFunction;
-
-    /** Optional: Zod schema for validation */
-    schema?: z.ZodType<any>;
-
-    /** Optional: If true, the transformer generates virtual modules (no file to read) */
-    virtual?: boolean;
-
-    /** Optional: additional options for this transformer */
-    options?: Record<string, unknown>;
-}
-
-/**
- * Widget compilation configuration
- */
-export interface WidgetConfig {
-    /**
-     * External dependencies that should not be bundled
-     * Default: ['react', 'react-dom', 'react/jsx-runtime']
-     */
-    external?: string[];
-
-    /**
-     * Path to tsconfig.json for widget compilation
-     * Default: './tsconfig.json'
-     */
-    tsconfig?: string;
-
-    /**
-     * Additional options to pass to @rollup/plugin-typescript
-     */
-    typescript?: Record<string, unknown>;
-
-    /**
-     * Minify widget output
-     * Default: false
-     */
-    minify?: boolean;
-}
-
-/**
- * Plugin configuration
- */
-export interface PluginConfig {
-    /** Array of transformer rules to apply */
-    transformers: TransformerRule[];
-
-    /**
-     * Root directory for asset output (scripts, widgets, etc.)
-     * - If specified: assets will be copied to this directory
-     * - If false: asset copying is disabled
-     * - Default: './dist'
-     */
-    assetsDir?: string | false;
-
-    /**
-     * Directory for script files relative to assetsDir
-     * Default: 'scripts'
-     */
-    scriptsDir?: string;
-
-    /**
-     * Directory for widget files relative to assetsDir
-     * Default: 'widgets'
-     */
-    widgetsDir?: string;
-
-    /**
-     * Widget compilation configuration
-     * If provided, discovered widgets will be automatically compiled
-     */
-    widgetConfig?: WidgetConfig;
-}
-
-/**
- * Type for transformer presets
- */
-export type TransformerPreset = TransformerRule;
-
-/**
- * Plugin factory return type
- */
-export type VertesiaImportPlugin = (config: PluginConfig) => Plugin;

package/src/utils/widget-compiler.ts

@@ -1,98 +0,0 @@
-/**
- * Widget compilation utility using Rollup
- */
-
-import { rollup, type RollupOptions, type Plugin } from 'rollup';
-import path from 'node:path';
-import type { WidgetConfig } from '../types.js';
-import type { WidgetMetadata } from './asset-discovery.js';
-
-/**
- * Default external dependencies for widgets
- */
-const DEFAULT_EXTERNALS = [
-    'react',
-    'react-dom',
-    'react/jsx-runtime',
-    'react/jsx-dev-runtime',
-    'react-dom/client'
-];
-
-/**
- * Compile widgets using Rollup
- *
- * @param widgets - Array of widget metadata to compile
- * @param outputDir - Directory to write compiled widgets
- * @param config - Widget compilation configuration
- * @returns Number of widgets compiled
- */
-export async function compileWidgets(
-    widgets: WidgetMetadata[],
-    outputDir: string,
-    config: WidgetConfig = {}
-): Promise<number> {
-    if (widgets.length === 0) {
-        return 0;
-    }
-
-    const {
-        external = DEFAULT_EXTERNALS,
-        tsconfig = './tsconfig.json',
-        typescript: typescriptOptions = {},
-        minify = false
-    } = config;
-
-    // Build each widget separately to get individual bundles
-    const buildPromises = widgets.map(async (widget) => {
-        // Dynamically import plugins - use any to bypass TypeScript module resolution issues
-        const typescript = (await import('@rollup/plugin-typescript' as any)).default as any;
-        const nodeResolve = (await import('@rollup/plugin-node-resolve' as any)).default as any;
-        const commonjs = (await import('@rollup/plugin-commonjs' as any)).default as any;
-
-        const plugins: Plugin[] = [
-            typescript({
-                tsconfig,
-                declaration: false,
-                sourceMap: true,
-                ...typescriptOptions
-            }),
-            nodeResolve({
-                browser: true,
-                preferBuiltins: false,
-                extensions: ['.tsx', '.ts', '.jsx', '.js']
-            }),
-            commonjs()
-        ];
-
-        // Add minification if requested
-        if (minify) {
-            const { terser } = await import('rollup-plugin-terser' as any);
-            plugins.push(
-                terser({
-                    compress: {
-                        drop_console: false
-                    }
-                })
-            );
-        }
-
-        const rollupConfig: RollupOptions = {
-            input: widget.path,
-            output: {
-                file: path.join(outputDir, `${widget.name}.js`),
-                format: 'es',
-                sourcemap: true,
-                inlineDynamicImports: true
-            },
-            external,
-            plugins
-        };
-
-        const bundle = await rollup(rollupConfig);
-        await bundle.write(rollupConfig.output as any);
-        await bundle.close();
-    });
-
-    await Promise.all(buildPromises);
-    return widgets.length;
-}

package/src/vite.ts

@@ -1,45 +0,0 @@
-/**
- * Vite-specific helpers for tool server development.
- *
- * Provides a pre-configured Vite plugin that handles SKILL.md, prompt,
- * and raw file imports — the same transforms used by rollup at build time.
- *
- * @example
- * ```typescript
- * // vite.server.config.ts
- * import { defineConfig } from 'vite';
- * import devServer from '@hono/vite-dev-server';
- * import { vertesiaDevServerPlugin } from '@vertesia/build-tools/vite';
- *
- * export default defineConfig({
- *     plugins: [
- *         vertesiaDevServerPlugin(),
- *         devServer({ entry: 'tools/server.ts' }),
- *     ],
- * });
- * ```
- */
-
-import type { Plugin } from 'rollup';
-import { vertesiaImportPlugin } from './plugin.js';
-import { skillTransformer, rawTransformer, promptTransformer } from './presets/index.js';
-import type { PluginConfig } from './types.js';
-
-/**
- * Creates a pre-configured Vite plugin for tool server dev mode.
- * Includes skill, prompt, and raw file transformers with asset copying disabled
- * (assets are only needed at build time, not during dev).
- *
- * @param overrides - Optional overrides for the plugin config
- */
-export function vertesiaDevServerPlugin(overrides?: Partial<PluginConfig>): Plugin {
-    return vertesiaImportPlugin({
-        transformers: [
-            skillTransformer,
-            promptTransformer,
-            rawTransformer,
-        ],
-        assetsDir: false,
-        ...overrides,
-    });
-}