@vertesia/build-tools 0.80.0

package/lib/types/presets/skill.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Skill transformer preset for markdown files with frontmatter
+ */
+import { z } from 'zod';
+import type { TransformerPreset } from '../types.js';
+/**
+ * Content type for skill instructions
+ */
+export type SkillContentType = 'md' | 'jst';
+/**
+ * MUST be kept in sync with @vertesia/tools-sdk SkillDefinition
+ * Zod schema for skill definition
+ * This validates the structure of skill objects generated from markdown
+ * Matches the SkillDefinition interface from @vertesia/tools-sdk
+ */
+export declare const SkillDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    instructions: z.ZodString;
+    content_type: z.ZodEnum<["md", "jst"]>;
+    input_schema: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "object";
+        properties?: Record<string, any> | undefined;
+        required?: string[] | undefined;
+    }, {
+        type: "object";
+        properties?: Record<string, any> | undefined;
+        required?: string[] | undefined;
+    }>>;
+    context_triggers: z.ZodOptional<z.ZodObject<{
+        keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        tool_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        data_patterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        keywords?: string[] | undefined;
+        tool_names?: string[] | undefined;
+        data_patterns?: string[] | undefined;
+    }, {
+        keywords?: string[] | undefined;
+        tool_names?: string[] | undefined;
+        data_patterns?: string[] | undefined;
+    }>>;
+    execution: z.ZodOptional<z.ZodObject<{
+        language: z.ZodString;
+        packages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        system_packages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        template: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        language: string;
+        packages?: string[] | undefined;
+        system_packages?: string[] | undefined;
+        template?: string | undefined;
+    }, {
+        language: string;
+        packages?: string[] | undefined;
+        system_packages?: string[] | undefined;
+        template?: string | undefined;
+    }>>;
+    related_tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    scripts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    widgets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    content_type: "md" | "jst";
+    instructions: string;
+    scripts?: string[] | undefined;
+    widgets?: string[] | undefined;
+    title?: string | undefined;
+    context_triggers?: {
+        keywords?: string[] | undefined;
+        tool_names?: string[] | undefined;
+        data_patterns?: string[] | undefined;
+    } | undefined;
+    execution?: {
+        language: string;
+        packages?: string[] | undefined;
+        system_packages?: string[] | undefined;
+        template?: string | undefined;
+    } | undefined;
+    related_tools?: string[] | undefined;
+    input_schema?: {
+        type: "object";
+        properties?: Record<string, any> | undefined;
+        required?: string[] | undefined;
+    } | undefined;
+}, {
+    name: string;
+    description: string;
+    content_type: "md" | "jst";
+    instructions: string;
+    scripts?: string[] | undefined;
+    widgets?: string[] | undefined;
+    title?: string | undefined;
+    context_triggers?: {
+        keywords?: string[] | undefined;
+        tool_names?: string[] | undefined;
+        data_patterns?: string[] | undefined;
+    } | undefined;
+    execution?: {
+        language: string;
+        packages?: string[] | undefined;
+        system_packages?: string[] | undefined;
+        template?: string | undefined;
+    } | undefined;
+    related_tools?: string[] | undefined;
+    input_schema?: {
+        type: "object";
+        properties?: Record<string, any> | undefined;
+        required?: string[] | undefined;
+    } | undefined;
+}>;
+/**
+ * TypeScript type inferred from the Zod schema
+ * Can also be imported from consumer packages for type safety
+ */
+export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>;
+/**
+ * Skill transformer preset
+ * Transforms markdown files with ?skill suffix OR SKILL.md files into skill definition objects
+ *
+ * Matches:
+ * - Files with ?skill suffix: ./my-skill.md?skill
+ * - SKILL.md files: ./my-skill/SKILL.md
+ *
+ * @example
+ * ```typescript
+ * import skill1 from './my-skill.md?skill';
+ * import skill2 from './my-skill/SKILL.md';
+ * // Both are SkillDefinition objects
+ * ```
+ */
+export declare const skillTransformer: TransformerPreset;
+//# sourceMappingURL=skill.d.ts.map

package/lib/types/presets/skill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../../src/presets/skill.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,KAAK,CAAC;AA6E5C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBhC,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAiGpE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,iBAyC9B,CAAC"}

package/lib/types/types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * 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';
+}
+/**
+ * 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: 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;
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;IAEnB,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;IAEjB,oCAAoC;IACpC,IAAI,EAAE,QAAQ,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,sDAAsD;IACtD,IAAI,EAAE,OAAO,CAAC;IAEd,gFAAgF;IAChF,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,+CAA+C;IAC/C,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IAErB,gDAAgD;IAChD,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACnD;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC5B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,KACf,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAEhB,iDAAiD;IACjD,SAAS,EAAE,iBAAiB,CAAC;IAE7B,0CAA0C;IAC1C,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAExB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAEpB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAErC;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,0CAA0C;IAC1C,YAAY,EAAE,eAAe,EAAE,CAAC;IAEhC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAE3B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,eAAe,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,EAAE,YAAY,KAAK,MAAM,CAAC"}

package/lib/types/utils/asset-copy.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Utilities for copying asset files during build
+ */
+import type { AssetFile } from '../types.js';
+/**
+ * Copy an asset file to its destination
+ *
+ * @param asset - Asset file information
+ * @param assetsRoot - Root directory for assets
+ */
+export declare function copyAssetFile(asset: AssetFile, assetsRoot: string): void;
+/**
+ * Copy multiple asset files
+ *
+ * @param assets - Array of asset files to copy
+ * @param assetsRoot - Root directory for assets
+ * @returns Number of files copied
+ */
+export declare function copyAssets(assets: AssetFile[], assetsRoot: string): number;
+//# sourceMappingURL=asset-copy.d.ts.map

package/lib/types/utils/asset-copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-copy.d.ts","sourceRoot":"","sources":["../../../src/utils/asset-copy.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAgB7C;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAgBxE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAS1E"}

package/lib/types/utils/asset-discovery.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Utilities for discovering asset files (scripts, widgets) in skill directories
+ */
+import type { AssetFile } from '../types.js';
+/**
+ * Widget metadata for compilation
+ */
+export interface WidgetMetadata {
+    /** Widget name (without .tsx extension) */
+    name: string;
+    /** Absolute path to widget file */
+    path: string;
+}
+/**
+ * Discovered assets in a skill directory
+ */
+export interface DiscoveredAssets {
+    /** Script file names (with extensions: .js, .py) */
+    scripts: string[];
+    /** Widget file names (without .tsx extension) */
+    widgets: string[];
+    /** Widget metadata for compilation */
+    widgetMetadata: WidgetMetadata[];
+    /** Asset files to be copied */
+    assetFiles: AssetFile[];
+}
+/**
+ * Discover assets (scripts and widgets) in a skill directory
+ *
+ * @param skillFilePath - Absolute path to the skill.md file
+ * @param options - Asset discovery options
+ * @returns Discovered assets and metadata
+ */
+export declare function discoverSkillAssets(skillFilePath: string, options?: {
+    scriptsDir?: string;
+    widgetsDir?: string;
+}): DiscoveredAssets;
+//# sourceMappingURL=asset-discovery.d.ts.map

package/lib/types/utils/asset-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-discovery.d.ts","sourceRoot":"","sources":["../../../src/utils/asset-discovery.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IAEb,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,oDAAoD;IACpD,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB,iDAAiD;IACjD,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB,sCAAsC;IACtC,cAAc,EAAE,cAAc,EAAE,CAAC;IAEjC,+BAA+B;IAC/B,UAAU,EAAE,SAAS,EAAE,CAAC;CAC3B;AAgDD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAC/B,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE;IACL,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CAClB,GACP,gBAAgB,CA0ClB"}

package/lib/types/utils/widget-compiler.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Widget compilation utility using Rollup
+ */
+import type { WidgetConfig } from '../types.js';
+import type { WidgetMetadata } from './asset-discovery.js';
+/**
+ * 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 declare function compileWidgets(widgets: WidgetMetadata[], outputDir: string, config?: WidgetConfig): Promise<number>;
+//# sourceMappingURL=widget-compiler.d.ts.map

package/lib/types/utils/widget-compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-compiler.d.ts","sourceRoot":"","sources":["../../../src/utils/widget-compiler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAa3D;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAChC,OAAO,EAAE,cAAc,EAAE,EACzB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,YAAiB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAiEjB"}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@vertesia/build-tools",
+  "version": "0.80.0",
+  "description": "Build tools for Vertesia projects - Rollup and Vite plugins for transforming imports, bundling skills, and compiling widgets",
+  "type": "module",
+  "main": "./lib/esm/index.js",
+  "types": "./lib/types/index.d.ts",
+  "files": [
+    "lib",
+    "src"
+  ],
+  "license": "Apache-2.0",
+  "exports": {
+    "types": "./lib/types/index.d.ts",
+    "import": "./lib/esm/index.js",
+    "require": "./lib/cjs/index.js"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/node": "^25.0.3",
+    "rollup": "^4.40.2",
+    "rollup-plugin-terser": "^7.0.2",
+    "ts-dual-module": "^0.6.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "zod": "^3.24.1"
+  },
+  "peerDependencies": {
+    "rollup": "^4.0.0"
+  },
+  "ts_dual_module": {
+    "outDir": "lib"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vertesia/composableai.git",
+    "directory": "packages/build-tools"
+  },
+  "keywords": [
+    "vertesia",
+    "rollup",
+    "rollup-plugin",
+    "vite",
+    "vite-plugin",
+    "build-tools",
+    "imports",
+    "transform",
+    "compiler",
+    "skill",
+    "markdown",
+    "frontmatter",
+    "widget",
+    "bundler",
+    "zod",
+    "validation"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "build": "pnpm exec tsmod build && pnpm exec rollup -c",
+    "clean": "rimraf ./node_modules ./lib ./tsconfig.tsbuildinfo"
+  }
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+/**
+ * Vertesia Rollup Import Plugin
+ *
+ * A flexible Rollup plugin for transforming imports with custom compilers and validation.
+ * Supports preset transformers for common use cases (skills, raw files) and custom transformers.
+ *
+ * @example
+ * ```typescript
+ * import { vertesiaImportPlugin, skillTransformer, rawTransformer } from '@vertesia/build-tools';
+ *
+ * export default {
+ *   plugins: [
+ *     vertesiaImportPlugin({
+ *       transformers: [skillTransformer, rawTransformer]
+ *     })
+ *   ]
+ * };
+ * ```
+ */
+
+// Core plugin
+export { vertesiaImportPlugin } from './plugin.js';
+
+// Types
+export type {
+    PluginConfig,
+    TransformerRule,
+    TransformerPreset,
+    TransformFunction,
+    TransformResult,
+    AssetFile,
+    WidgetConfig
+} from './types.js';
+
+// Presets
+export {
+    skillTransformer,
+    rawTransformer,
+    SkillDefinitionSchema,
+    type SkillDefinition,
+    type SkillContentType
+} from './presets/index.js';
+
+// Utilities
+export { parseFrontmatter, type FrontmatterResult } from './parsers/frontmatter.js';

package/src/parsers/frontmatter.ts

@@ -0,0 +1,32 @@
+/**
+ * Frontmatter parser utility using gray-matter
+ */
+
+import matter from 'gray-matter';
+
+export interface FrontmatterResult {
+    /** Parsed frontmatter data */
+    frontmatter: Record<string, any>;
+
+    /** Content without frontmatter */
+    content: string;
+
+    /** Original full content */
+    original: string;
+}
+
+/**
+ * Parse YAML frontmatter from markdown content
+ *
+ * @param content - Raw markdown content with optional frontmatter
+ * @returns Parsed frontmatter and content
+ */
+export function parseFrontmatter(content: string): FrontmatterResult {
+    const result = matter(content);
+
+    return {
+        frontmatter: result.data,
+        content: result.content,
+        original: content
+    };
+}

package/src/plugin.ts

@@ -0,0 +1,158 @@
+/**
+ * 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, '');
+                        const resolved = path.resolve(path.dirname(importer), 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
+                const content = 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
+                if (result.code) {
+                    // Custom code provided
+                    return result.code;
+                } else {
+                    // Default: export data (escape if string, otherwise stringify as JSON)
+                    const imports = result.imports ? result.imports.join('\n') + '\n\n' : '';
+                    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

@@ -0,0 +1,6 @@
+/**
+ * Preset transformers for common use cases
+ */
+
+export { skillTransformer, SkillDefinitionSchema, type SkillDefinition, type SkillContentType } from './skill.js';
+export { rawTransformer } from './raw.js';