@aigne/core 0.0.1

package/lib/cjs/types/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./assistant"), exports);
+__exportStar(require("./runtime"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./resource"), exports);

package/lib/cjs/types/resource/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceTypes = void 0;
+exports.validateResourceProject = validateResourceProject;
+const joi_1 = __importDefault(require("joi"));
+const project_1 = require("./project");
+__exportStar(require("./project"), exports);
+exports.ResourceTypes = [
+    'application',
+    'tool',
+    'llm-adapter',
+    'aigc-adapter',
+    'knowledge',
+    'template',
+    'example',
+];
+const resourceProjectSchema = joi_1.default.object({
+    project: project_1.projectSettingsSchema.required(),
+    agents: joi_1.default.array().items(joi_1.default.object()).required(),
+    config: joi_1.default.object().default({}),
+    cron: joi_1.default.object().default({}),
+    memory: joi_1.default.object().default({}),
+}).options({ stripUnknown: true });
+async function validateResourceProject(value) {
+    return resourceProjectSchema.validateAsync({
+        ...value,
+        agents: value.agents || value.assistants,
+        cron: value.cron || value.cronConfig,
+    });
+}

package/lib/cjs/types/resource/project.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectSettingsSchema = void 0;
+const joi_1 = __importDefault(require("joi"));
+exports.projectSettingsSchema = joi_1.default.object({
+    id: joi_1.default.string().required(),
+    name: joi_1.default.string().empty(['', null]),
+    description: joi_1.default.string().empty(['', null]),
+    model: joi_1.default.string().empty(['', null]),
+    temperature: joi_1.default.number().empty(['', null]),
+    topP: joi_1.default.number().empty(['', null]),
+    presencePenalty: joi_1.default.number().empty(['', null]),
+    frequencyPenalty: joi_1.default.number().empty(['', null]),
+    maxTokens: joi_1.default.number().empty(['', null]),
+    createdAt: joi_1.default.alternatives(joi_1.default.string().isoDate(), joi_1.default.date().cast('string')).empty(['', null]),
+    updatedAt: joi_1.default.alternatives(joi_1.default.string().isoDate(), joi_1.default.date().cast('string')).empty(['', null]),
+    createdBy: joi_1.default.string().empty(['', null]),
+    updatedBy: joi_1.default.string().empty(['', null]),
+    appearance: joi_1.default.object({
+        primaryColor: joi_1.default.string().empty(['', null]),
+        typography: joi_1.default.object({
+            fontFamily: joi_1.default.string().empty(['', null]),
+            heading: joi_1.default.object({
+                fontFamily: joi_1.default.string().empty(['', null]),
+            }).empty(['', null]),
+        }).empty(['', null]),
+    }).empty(['', null]),
+    readme: joi_1.default.string().empty(['', null]).optional(),
+    executor: joi_1.default.object().empty(['', null]).optional(),
+})
+    .rename('_id', 'id', { override: true, ignoreUndefined: true })
+    .options({ stripUnknown: true });

package/lib/cjs/types/runtime/agent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/types/runtime/error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeError = exports.RuntimeErrorType = void 0;
+var RuntimeErrorType;
+(function (RuntimeErrorType) {
+    RuntimeErrorType["MissingSecretError"] = "MissingSecretError";
+    RuntimeErrorType["RequestExceededError"] = "RequestExceededError";
+    RuntimeErrorType["ProjectOwnerRequestExceededError"] = "ProjectOwnerRequestExceededError";
+    RuntimeErrorType["ProjectLimitExceededError"] = "ProjectLimitExceededError";
+})(RuntimeErrorType || (exports.RuntimeErrorType = RuntimeErrorType = {}));
+class RuntimeError extends Error {
+    type;
+    constructor(type, message) {
+        super(message);
+        this.type = type;
+    }
+}
+exports.RuntimeError = RuntimeError;

package/lib/cjs/types/runtime/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssistantResponseType = exports.ExecutionPhase = void 0;
+__exportStar(require("./schema"), exports);
+__exportStar(require("./error"), exports);
+var ExecutionPhase;
+(function (ExecutionPhase) {
+    ExecutionPhase["EXECUTE_BLOCK_START"] = "EXECUTE_BLOCK_START";
+    ExecutionPhase["EXECUTE_SELECT_STOP"] = "EXECUTE_SELECT_STOP";
+    ExecutionPhase["EXECUTE_ASSISTANT_START"] = "EXECUTE_ASSISTANT_START";
+    ExecutionPhase["EXECUTE_ASSISTANT_RUNNING"] = "EXECUTE_BLOCK_RUNNING";
+    ExecutionPhase["EXECUTE_ASSISTANT_END"] = "EXECUTE_ASSISTANT_END";
+})(ExecutionPhase || (exports.ExecutionPhase = ExecutionPhase = {}));
+var AssistantResponseType;
+(function (AssistantResponseType) {
+    AssistantResponseType["ERROR"] = "ERROR";
+    AssistantResponseType["LOG"] = "LOG";
+    AssistantResponseType["INPUT"] = "INPUT";
+    AssistantResponseType["CHUNK"] = "CHUNK";
+    AssistantResponseType["USAGE"] = "USAGE";
+    AssistantResponseType["EXECUTE"] = "EXECUTE";
+    AssistantResponseType["INPUT_PARAMETER"] = "INPUT_PARAMETER";
+})(AssistantResponseType || (exports.AssistantResponseType = AssistantResponseType = {}));

package/lib/cjs/types/runtime/runtime-resource-blocklet-state.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_RESOURCE_BLOCKLET_STATE_GLOBAL_VARIABLE = void 0;
+exports.RUNTIME_RESOURCE_BLOCKLET_STATE_GLOBAL_VARIABLE = '__AI_RUNTIME_RESOURCE_BLOCKLET_STATE__';

package/lib/cjs/types/runtime/schema.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeOutputVariable = exports.runtimeVariablesSchema = exports.variableBlockListForAgent = void 0;
+exports.outputVariablesToJsonSchema = outputVariablesToJsonSchema;
+exports.outputVariablesToJoiSchema = outputVariablesToJoiSchema;
+exports.isRuntimeOutputVariable = isRuntimeOutputVariable;
+exports.jsonSchemaToOpenAIJsonSchema = jsonSchemaToOpenAIJsonSchema;
+const joi_1 = __importDefault(require("joi"));
+const omitBy_1 = __importDefault(require("lodash/omitBy"));
+const toLower_1 = __importDefault(require("lodash/toLower"));
+exports.variableBlockListForAgent = {
+    prompt: {
+    // block: new Set(['$images']),
+    },
+    image: {
+    // allow: new Set(['$images']),
+    },
+};
+exports.runtimeVariablesSchema = {
+    $text: {
+        type: 'string',
+        description: 'Text Stream',
+        faker: 'lorem.paragraph',
+    },
+    $images: {
+        type: 'array',
+        description: 'Generated Images',
+        element: {
+            id: '',
+            type: 'object',
+            properties: [
+                {
+                    id: '',
+                    type: 'string',
+                    name: 'url',
+                    description: 'Image Url',
+                    required: true,
+                    faker: 'image.url',
+                },
+            ],
+        },
+    },
+    '$suggested.questions': {
+        type: 'array',
+        description: 'Generate 3 questions for users to ask you based on answers and context',
+        element: {
+            id: '',
+            type: 'object',
+            properties: [
+                {
+                    id: '',
+                    type: 'string',
+                    name: 'question',
+                    required: true,
+                    faker: 'lorem.sentence',
+                },
+            ],
+        },
+        required: true,
+    },
+    '$reference.links': {
+        type: 'array',
+        description: 'List all referenced links in the generated text',
+        element: {
+            id: '',
+            type: 'object',
+            properties: [
+                {
+                    id: '',
+                    type: 'string',
+                    name: 'title',
+                    required: true,
+                    faker: 'lorem.sentence',
+                },
+                {
+                    id: '',
+                    type: 'string',
+                    name: 'url',
+                    required: true,
+                    faker: 'internet.url',
+                },
+            ],
+        },
+        required: true,
+    },
+};
+function outputVariablesToJsonSchema(assistant, { variables, includeRuntimeOutputVariables, includeFaker, }) {
+    const variableToSchema = (variable) => {
+        if (variable.from?.type === 'input')
+            return undefined;
+        if (!includeRuntimeOutputVariables && ignoreJsonSchemaOutputs.has(variable.name))
+            return undefined;
+        if (variable.name && isRuntimeOutputVariable(variable.name)) {
+            const runtimeVariable = exports.runtimeVariablesSchema[variable.name];
+            if (!runtimeVariable)
+                return undefined;
+            return variableToSchema({
+                ...runtimeVariable,
+                description: [runtimeVariable.description, variable.description].filter((i) => !!i).join('\n'),
+            });
+        }
+        if (variable.variable) {
+            const { key, scope } = variable.variable;
+            const v = variables.find((i) => (0, toLower_1.default)(i.key) === (0, toLower_1.default)(key) && i.scope === scope);
+            if (!v?.type)
+                throw new Error(`Variable ${key} not found from ${scope}`);
+            return variableToSchema(v.type);
+        }
+        return (0, omitBy_1.default)({
+            type: variable.type || 'string',
+            description: variable.description,
+            properties: variable.type === 'object' && variable.properties
+                ? Object.fromEntries(variable.properties
+                    .map((property) => [property.name, variableToSchema(property)])
+                    .filter((i) => i[0] && i[1]))
+                : undefined,
+            items: variable.type === 'array' && variable.element ? variableToSchema(variable.element) : undefined,
+            additionalProperties: variable.type === 'object' ? false : undefined,
+            required: variable.type === 'object' && variable.properties?.length
+                ? variable.properties
+                    .filter((i) => i.name &&
+                    (i.required ||
+                        (runtimeOutputVariableSet.has(i.name) &&
+                            exports.runtimeVariablesSchema[i.name] &&
+                            !ignoreJsonSchemaOutputs.has(i.name))))
+                    .map((i) => i.name)
+                : undefined,
+            faker: includeFaker ? variable.faker : undefined,
+        }, (v) => v === undefined);
+    };
+    const outputVariables = (assistant.outputVariables ?? []).filter((i) => !i.hidden && i.from?.type !== 'callAgent' && !i.valueTemplate?.trim());
+    return variableToSchema({ type: 'object', properties: outputVariables });
+}
+function outputVariablesToJoiSchema(assistant, { partial, variables }) {
+    const variableToSchema = (variable) => {
+        let schema;
+        if (variable.from?.type === 'input') {
+            const fromId = variable.from.id;
+            const input = assistant.parameters?.find((i) => i.id === fromId && !i.hidden);
+            if (input) {
+                return joi_1.default.any();
+            }
+            return undefined;
+        }
+        if (variable.from?.type === 'output') {
+            return joi_1.default.any();
+        }
+        if (variable.name && isRuntimeOutputVariable(variable.name)) {
+            if (variable.name === RuntimeOutputVariable.llmResponseStream) {
+                schema = joi_1.default.any();
+            }
+            else {
+                const runtimeVariable = exports.runtimeVariablesSchema[variable.name];
+                if (!runtimeVariable)
+                    return undefined;
+                schema = variableToSchema({ ...runtimeVariable });
+                if (schema) {
+                    schema = joi_1.default.alternatives().try(schema, joi_1.default.any().empty(joi_1.default.any()));
+                }
+            }
+            return schema;
+        }
+        if (variable.variable) {
+            const { key, scope } = variable.variable;
+            const v = variables.find((i) => (0, toLower_1.default)(i.key) === (0, toLower_1.default)(key) && i.scope === scope);
+            if (!v?.type)
+                return undefined;
+            schema = variableToSchema(v.type);
+        }
+        else if (!variable.type || variable.type === 'string') {
+            schema = joi_1.default.string().empty(['', null]);
+        }
+        else if (variable.type === 'number') {
+            schema = joi_1.default.number().empty([null, '']);
+        }
+        else if (variable.type === 'boolean') {
+            schema = joi_1.default.boolean().empty([null, '']);
+        }
+        else if (variable.type === 'object') {
+            if (variable.properties?.length) {
+                schema = joi_1.default.object(Object.fromEntries((variable.properties ?? [])
+                    .map((property) => [property.name, variableToSchema(property)])
+                    .filter((i) => i[0] && i[1])))
+                    .empty([null, ''])
+                    .options({ stripUnknown: true });
+            }
+            else {
+                schema = joi_1.default.any().empty(['', null]);
+            }
+        }
+        else if (variable.type === 'array') {
+            schema = joi_1.default.array()
+                .empty([null, ''])
+                .items((variable.element && variableToSchema(variable.element)) || joi_1.default.string().empty([null, '']));
+        }
+        if (!schema)
+            return undefined;
+        if ('defaultValue' in variable) {
+            schema = schema.default(variable.defaultValue);
+        }
+        if (variable.required) {
+            schema = schema.required();
+        }
+        return schema;
+    };
+    const outputVariables = (assistant.outputVariables ?? []).filter((i) => !i.hidden && i.from?.type !== 'callAgent' && !i.valueTemplate);
+    return variableToSchema({
+        type: 'object',
+        properties: partial ? outputVariables.map((i) => ({ ...i, required: false })) : outputVariables,
+    });
+}
+var RuntimeOutputVariable;
+(function (RuntimeOutputVariable) {
+    RuntimeOutputVariable["llmResponseStream"] = "$llmResponseStream";
+    RuntimeOutputVariable["text"] = "$text";
+    RuntimeOutputVariable["images"] = "$images";
+    RuntimeOutputVariable["suggestedQuestions"] = "$suggested.questions";
+    RuntimeOutputVariable["referenceLinks"] = "$reference.links";
+    RuntimeOutputVariable["appearancePage"] = "$appearance.page";
+    RuntimeOutputVariable["appearanceInput"] = "$appearance.input";
+    RuntimeOutputVariable["appearanceOutput"] = "$appearance.output";
+    RuntimeOutputVariable["children"] = "$children";
+    RuntimeOutputVariable["share"] = "$share";
+    RuntimeOutputVariable["openingQuestions"] = "$openingQuestions";
+    RuntimeOutputVariable["openingMessage"] = "$openingMessage";
+    RuntimeOutputVariable["profile"] = "$profile";
+})(RuntimeOutputVariable || (exports.RuntimeOutputVariable = RuntimeOutputVariable = {}));
+const runtimeOutputVariableSet = new Set(Object.values(RuntimeOutputVariable));
+const ignoreJsonSchemaOutputs = new Set([
+    RuntimeOutputVariable.text,
+    RuntimeOutputVariable.images,
+]);
+function isRuntimeOutputVariable(variable) {
+    return Object.values(RuntimeOutputVariable).includes(variable);
+}
+function jsonSchemaToOpenAIJsonSchema(schema) {
+    if (schema?.type === 'object') {
+        const { required, properties } = schema;
+        return {
+            ...schema,
+            properties: Object.fromEntries(Object.entries(properties).map(([key, value]) => {
+                const valueSchema = jsonSchemaToOpenAIJsonSchema(value);
+                // NOTE: All fields must be required https://platform.openai.com/docs/guides/structured-outputs/all-fields-must-be-required
+                return [key, required?.includes(key) ? valueSchema : { anyOf: [valueSchema, { type: ['null'] }] }];
+            })),
+            required: Object.keys(properties),
+        };
+    }
+    if (schema?.type === 'array') {
+        return {
+            ...schema,
+            items: jsonSchemaToOpenAIJsonSchema(schema.items),
+        };
+    }
+    return schema;
+}

package/lib/cjs/utils/cron-job.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronJobManager = exports.CronJobDefaultGroup = void 0;
+const cron_1 = require("cron");
+exports.CronJobDefaultGroup = 'default';
+class CronJobManager {
+    groups = {};
+    resetJobs(jobs, { groupId = exports.CronJobDefaultGroup } = {}) {
+        this.destroyGroup({ groupId });
+        for (const job of jobs) {
+            this.resetJob(job, { groupId });
+        }
+    }
+    resetJob(job, { groupId = exports.CronJobDefaultGroup } = {}) {
+        if (!job.cronTime)
+            throw new Error('cronTime is required');
+        this.groups[groupId] ??= { jobs: {} };
+        const group = this.groups[groupId];
+        this.stopJob(job.id, { groupId });
+        const cronJob = cron_1.CronJob.from({ cronTime: job.cronTime, onTick: job.onTick, utcOffset: 0, start: true });
+        group.jobs[job.id] = { cronJob, job };
+    }
+    stopJob(jobId, { groupId = exports.CronJobDefaultGroup } = {}) {
+        const group = this.groups[groupId];
+        if (!group)
+            return;
+        const item = group.jobs[jobId];
+        if (!item)
+            return;
+        item.cronJob.stop();
+        delete group.jobs[jobId];
+    }
+    destroyGroup({ groupId }) {
+        const group = this.groups[groupId];
+        if (!group)
+            return;
+        for (const item of Object.values(group.jobs)) {
+            this.stopJob(item.job.id, { groupId });
+        }
+        delete this.groups[groupId];
+    }
+    destroy() {
+        for (const groupId of Object.keys(this.groups)) {
+            this.destroyGroup({ groupId });
+        }
+    }
+}
+exports.CronJobManager = CronJobManager;

package/lib/cjs/utils/extract-metadata-transform.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractMetadataTransform = void 0;
+const web_1 = require("stream/web");
+class ExtractMetadataTransform extends web_1.TransformStream {
+    buffer = '';
+    cursor = 0;
+    state = 'none';
+    constructor({ start, end }) {
+        super({
+            transform: async (chunk, controller) => {
+                if (!start || !end) {
+                    controller.enqueue({ type: 'text', text: chunk });
+                    return;
+                }
+                this.buffer += chunk;
+                for (;;) {
+                    if (this.state === 'none') {
+                        const found = findMatchIndex(this.buffer, this.cursor, start);
+                        if (found.start > this.cursor) {
+                            const text = this.buffer.slice(this.cursor, found.start);
+                            this.cursor = found.start;
+                            controller.enqueue({ type: 'text', text });
+                        }
+                        if (found.end) {
+                            this.state = 'start';
+                            this.cursor = found.end;
+                        }
+                    }
+                    if (this.state === 'start') {
+                        const found = findMatchIndex(this.buffer, this.cursor, end);
+                        if (found.end) {
+                            const match = this.buffer.slice(this.cursor, found.start);
+                            controller.enqueue({ type: 'match', text: match });
+                            this.state = 'none';
+                            this.cursor = found.end;
+                            continue;
+                        }
+                    }
+                    break;
+                }
+            },
+        });
+    }
+}
+exports.ExtractMetadataTransform = ExtractMetadataTransform;
+function findMatchIndex(str, position, match) {
+    const i = str.indexOf(match, position);
+    if (i >= 0)
+        return { start: i, end: i + match.length };
+    for (let i = match.length - 1; i > 0; i--) {
+        const m = match.slice(0, i);
+        if (str.endsWith(m)) {
+            return { start: str.length - m.length };
+        }
+    }
+    return { start: str.length };
+}

package/lib/cjs/utils/extract-metadata-transform.test.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web_1 = require("stream/web");
+const globals_1 = require("@jest/globals");
+const extract_metadata_transform_1 = require("./extract-metadata-transform");
+(0, globals_1.describe)('ExtractMetadataTransform', () => {
+    async function run(str, start, end, step = 1) {
+        const s = new web_1.ReadableStream({
+            start(controller) {
+                let t = '';
+                for (const i of str) {
+                    t += i;
+                    if (t.length === step) {
+                        controller.enqueue(t);
+                        t = '';
+                    }
+                }
+                controller.enqueue(t);
+                controller.close();
+            },
+        }).pipeThrough(new extract_metadata_transform_1.ExtractMetadataTransform({ start, end }));
+        let text = '';
+        const matched = [];
+        for await (const i of s) {
+            if (i.type === 'text') {
+                text += i.text;
+            }
+            else if (i.type === 'match') {
+                matched.push(i.text);
+            }
+        }
+        return { text, matched };
+    }
+    const cases = [
+        {
+            input: 'hello<metadata>{"name":"foo","age":120}</metadata>world how<metadata>{"name":"bar","age":130}</metadata> to',
+            start: '<metadata>',
+            end: '</metadata>',
+            expected: { text: 'helloworld how to', matched: ['{"name":"foo","age":120}', '{"name":"bar","age":130}'] },
+        },
+        {
+            input: '```metadata{"name":"foo","age":120}```',
+            start: '```metadata',
+            end: '```',
+            expected: { text: '', matched: ['{"name":"foo","age":120}'] },
+        },
+        {
+            input: '```metadata{"name":"foo","age":120}``````metadata{"name":"bar","age":130}```',
+            start: '```metadata',
+            end: '```',
+            expected: { text: '', matched: ['{"name":"foo","age":120}', '{"name":"bar","age":130}'] },
+        },
+    ];
+    (0, globals_1.test)('extract metadata transform', async () => {
+        for (const c of cases) {
+            for (let i = 1; i < c.input.length; i++) {
+                (0, globals_1.expect)([await run(c.input, c.start, c.end, i), i]).toEqual([c.expected, i]);
+            }
+        }
+    });
+});

package/lib/cjs/utils/fs.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyFile = copyFile;
+exports.copyDirectory = copyDirectory;
+exports.copyRecursive = copyRecursive;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function copyFile(src, dest, { skip } = {}) {
+    if (skip?.(src))
+        return;
+    await new Promise((resolve, reject) => {
+        const readStream = fs_1.default.createReadStream(src);
+        const writeStream = fs_1.default.createWriteStream(dest);
+        readStream.on('error', reject);
+        writeStream.on('error', reject);
+        writeStream.on('finish', resolve);
+        readStream.pipe(writeStream);
+    });
+}
+async function copyDirectory(src, dest, { skip } = {}) {
+    if (skip?.(src))
+        return;
+    await fs_1.default.promises.mkdir(dest, { recursive: true });
+    const entries = await fs_1.default.promises.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path_1.default.join(src, entry.name);
+        const destPath = path_1.default.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(srcPath, destPath, { skip });
+        }
+        else {
+            await copyFile(srcPath, destPath, { skip });
+        }
+    }
+}
+async function copyRecursive(src, dest, { skip } = {}) {
+    if (skip?.(src))
+        return;
+    const srcStats = await fs_1.default.promises.stat(src);
+    if (srcStats.isDirectory()) {
+        await copyDirectory(src, dest, { skip });
+    }
+    else {
+        await copyFile(src, dest, { skip });
+    }
+}