@prompty/core 0.1.2

package/README.md

@@ -0,0 +1,2 @@
+# WiP
+Test change

package/dist/index.d.mts

@@ -0,0 +1,84 @@
+declare class PropertySettings {
+    type: string;
+    default: any;
+    description: string;
+}
+interface OpenAIModel {
+    type: "openai";
+    name: string;
+    organization?: string;
+    api_key: string;
+    base_url?: string;
+}
+interface AzureOpenAIModel {
+    type: "azure_openai";
+    api_version: string;
+    azure_deployment: string;
+    azure_endpoint: string;
+    api_key?: string;
+}
+interface MaasModel {
+    type: "serverless";
+    endpoint: string;
+    model: string;
+    api_key?: string;
+}
+type ModelConfiguration = OpenAIModel | AzureOpenAIModel | MaasModel;
+declare class ModelSettings {
+    api: string;
+    configuration: ModelConfiguration;
+    parameters: any;
+    response: any;
+}
+declare class TemplateSettings {
+    type: string;
+    parser: string;
+}
+declare class Prompty {
+    name: string;
+    description: string;
+    authors: string[];
+    tags: string[];
+    version: string;
+    base: string;
+    basePrompty: Prompty;
+    model: ModelSettings;
+    sample: any;
+    input: {
+        [key: string]: PropertySettings;
+    };
+    output: {
+        [key: string]: PropertySettings;
+    };
+    template: TemplateSettings;
+    file: string;
+    content: string;
+    constructor(content: string);
+    static prepare(prompt: Prompty, inputs?: any): Promise<any>;
+    static load(filePath: string): Promise<any>;
+    static export(prompt: Prompty): string;
+}
+
+declare abstract class Invoker {
+    prompty: Prompty;
+    constructor(prompty?: Prompty);
+    abstract invoke(data: any): Promise<any>;
+    abstract invokeSync(data: any): any;
+    call(data: any): Promise<any>;
+    callSync(data: any): any;
+}
+type InvokerConstructor = new (prompty: Prompty) => Invoker;
+type InvokerType = "renderer" | "parser" | "executor" | "processor";
+declare class InvokerFactory {
+    private static _instance;
+    private _invokers;
+    register(type: InvokerType, name: string, invokerClass: InvokerConstructor): void;
+    create(type: InvokerType, name: string, prompty: Prompty): Invoker;
+    static getInstance(): InvokerFactory;
+    call(type: InvokerType, name: string, prompty: Prompty, data: any): Promise<any>;
+    callSync(type: InvokerType, name: string, prompty: Prompty, data: any): any;
+    toDict(): Record<string, Record<string, string>>;
+    toJson(): string;
+}
+
+export { Invoker, InvokerFactory, type MaasModel, type ModelConfiguration, Prompty };

package/dist/index.d.ts

@@ -0,0 +1,84 @@
+declare class PropertySettings {
+    type: string;
+    default: any;
+    description: string;
+}
+interface OpenAIModel {
+    type: "openai";
+    name: string;
+    organization?: string;
+    api_key: string;
+    base_url?: string;
+}
+interface AzureOpenAIModel {
+    type: "azure_openai";
+    api_version: string;
+    azure_deployment: string;
+    azure_endpoint: string;
+    api_key?: string;
+}
+interface MaasModel {
+    type: "serverless";
+    endpoint: string;
+    model: string;
+    api_key?: string;
+}
+type ModelConfiguration = OpenAIModel | AzureOpenAIModel | MaasModel;
+declare class ModelSettings {
+    api: string;
+    configuration: ModelConfiguration;
+    parameters: any;
+    response: any;
+}
+declare class TemplateSettings {
+    type: string;
+    parser: string;
+}
+declare class Prompty {
+    name: string;
+    description: string;
+    authors: string[];
+    tags: string[];
+    version: string;
+    base: string;
+    basePrompty: Prompty;
+    model: ModelSettings;
+    sample: any;
+    input: {
+        [key: string]: PropertySettings;
+    };
+    output: {
+        [key: string]: PropertySettings;
+    };
+    template: TemplateSettings;
+    file: string;
+    content: string;
+    constructor(content: string);
+    static prepare(prompt: Prompty, inputs?: any): Promise<any>;
+    static load(filePath: string): Promise<any>;
+    static export(prompt: Prompty): string;
+}
+
+declare abstract class Invoker {
+    prompty: Prompty;
+    constructor(prompty?: Prompty);
+    abstract invoke(data: any): Promise<any>;
+    abstract invokeSync(data: any): any;
+    call(data: any): Promise<any>;
+    callSync(data: any): any;
+}
+type InvokerConstructor = new (prompty: Prompty) => Invoker;
+type InvokerType = "renderer" | "parser" | "executor" | "processor";
+declare class InvokerFactory {
+    private static _instance;
+    private _invokers;
+    register(type: InvokerType, name: string, invokerClass: InvokerConstructor): void;
+    create(type: InvokerType, name: string, prompty: Prompty): Invoker;
+    static getInstance(): InvokerFactory;
+    call(type: InvokerType, name: string, prompty: Prompty, data: any): Promise<any>;
+    callSync(type: InvokerType, name: string, prompty: Prompty, data: any): any;
+    toDict(): Record<string, Record<string, string>>;
+    toJson(): string;
+}
+
+export { Invoker, InvokerFactory, type MaasModel, type ModelConfiguration, Prompty };

package/dist/index.js

@@ -0,0 +1,354 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Invoker: () => Invoker,
+  InvokerFactory: () => InvokerFactory,
+  Prompty: () => Prompty
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core.ts
+var import_gray_matter = __toESM(require("gray-matter"));
+
+// src/utils.ts
+var fs = __toESM(require("fs/promises"));
+var _utils = class _utils {
+  static async readFileSafe(filePath, encoding = "utf-8") {
+    if (_utils.isNode) {
+      const data = await fs.readFile(filePath, encoding);
+      return data;
+    } else {
+      throw new Error("Load from file not supported in browser");
+    }
+  }
+  static paramHoisting(top, bottom, topKey = null) {
+    let newDict = {};
+    if (topKey) {
+      newDict = topKey in top ? { ...top[topKey] } : {};
+    } else {
+      newDict = { ...top };
+    }
+    for (const key in bottom) {
+      if (!(key in newDict)) {
+        newDict[key] = bottom[key];
+      }
+    }
+    return newDict;
+  }
+};
+_utils.isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var utils = _utils;
+
+// src/invokerFactory.ts
+var Invoker = class {
+  constructor(prompty) {
+    this.prompty = prompty;
+  }
+  async call(data) {
+    return await this.invoke(data);
+  }
+  callSync(data) {
+    return this.invokeSync(data);
+  }
+};
+var NoOpInvoker = class extends Invoker {
+  async invoke(data) {
+    return Promise.resolve(data);
+  }
+  invokeSync(data) {
+    return data;
+  }
+};
+var InvokerFactory = class _InvokerFactory {
+  constructor() {
+    this._invokers = {
+      renderer: { ["NOOP"]: NoOpInvoker },
+      parser: { ["NOOP"]: NoOpInvoker },
+      executor: { ["NOOP"]: NoOpInvoker },
+      processor: { ["NOOP"]: NoOpInvoker }
+    };
+  }
+  register(type, name, invokerClass) {
+    if (!this._invokers[type]) {
+      throw new Error(`Invalid invoker type: ${type}`);
+    }
+    this._invokers[type][name] = invokerClass;
+  }
+  create(type, name, prompty) {
+    const invokerClass = this._invokers[type][name];
+    if (!invokerClass) {
+      throw new Error(`No registered ${type} for name: ${name}`);
+    }
+    return new invokerClass(prompty);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _InvokerFactory();
+    }
+    return this._instance;
+  }
+  async call(type, name, prompty, data) {
+    return await this.create(type, name, prompty).call(data);
+  }
+  callSync(type, name, prompty, data) {
+    return this.create(type, name, prompty).callSync(data);
+  }
+  toDict() {
+    const dict = {};
+    for (const [type, invokers] of Object.entries(this._invokers)) {
+      dict[type] = Object.fromEntries(
+        Object.entries(invokers).map(([key, value]) => [key, value.name])
+      );
+    }
+    return dict;
+  }
+  toJson() {
+    return JSON.stringify(this.toDict());
+  }
+};
+
+// src/parsers.ts
+var path = __toESM(require("path"));
+var PromptyChatParser = class extends Invoker {
+  constructor(prompty) {
+    super(prompty);
+    this.roles = ["assistant", "function", "system", "user"];
+  }
+  async inlineImage(imageItem) {
+    if (imageItem.startsWith("http") || imageItem.startsWith("data")) {
+      return imageItem;
+    } else {
+      if (utils.isNode) {
+        const imagePath = path.join(path.dirname(this.prompty.file), imageItem);
+        const fileContent = await utils.readFileSafe(imagePath, "base64");
+        const extension = path.extname(imagePath).toLowerCase();
+        switch (extension) {
+          case ".png":
+            return `data:image/png;base64,${fileContent}`;
+          case ".jpg":
+          case ".jpeg":
+            return `data:image/jpeg;base64,${fileContent}`;
+          default:
+            throw new Error(`Invalid image format ${extension} - currently only .png and .jpg/.jpeg are supported.`);
+        }
+      } else {
+        throw new Error("Load from file not supported in browser");
+      }
+    }
+  }
+  async parseContent(content, role) {
+    const imageRegex = /!\[(.*?)\]\((.*?)\)/gm;
+    let matches;
+    let contentItems = [];
+    let contentChunks = content.split(imageRegex);
+    for (let index = 0; index < contentChunks.length; index++) {
+      const chunk = contentChunks[index];
+      if (index % 3 === 0 && chunk.trim()) {
+        contentItems.push({ type: "text", text: chunk.trim() });
+      } else if (index % 3 === 2) {
+        const base64Str = await this.inlineImage(chunk.split(" ")[0].trim());
+        let msg = {
+          type: "image_url",
+          image_url: { url: base64Str }
+        };
+        contentItems.push(msg);
+      }
+    }
+    return contentItems;
+  }
+  invokeSync(data) {
+    throw new Error("Not Supported");
+  }
+  async invoke(data) {
+    let messages = [];
+    const separator = new RegExp(`\\s*#?\\s*(${this.roles.join("|")})\\s*:\\s*\\n`, "im");
+    let chunks = data.split(separator).filter((chunk) => chunk.trim());
+    if (!this.roles.includes(chunks[0].trim().toLowerCase())) {
+      chunks.unshift("system");
+    }
+    if (this.roles.includes(chunks[chunks.length - 1].trim().toLowerCase())) {
+      chunks.pop();
+    }
+    if (chunks.length % 2 !== 0) {
+      throw new Error("Invalid prompt format");
+    }
+    for (let i = 0; i < chunks.length; i += 2) {
+      const role = chunks[i].trim().toLowerCase();
+      const content = chunks[i + 1].trim();
+      const parsedContent = await this.parseContent(content, role);
+      messages.push({ role, content: parsedContent });
+    }
+    return messages;
+  }
+};
+var factory = InvokerFactory.getInstance();
+factory.register("parser", "prompty.chat", PromptyChatParser);
+factory.register("parser", "prompty.embedding", NoOpInvoker);
+factory.register("parser", "prompty.image", NoOpInvoker);
+factory.register("parser", "prompty.completion", NoOpInvoker);
+
+// src/renderers.ts
+var nunjucks = __toESM(require("nunjucks"));
+var mustache = __toESM(require("mustache"));
+var NunjucksRenderer = class extends Invoker {
+  constructor() {
+    super(...arguments);
+    this.templates = {};
+  }
+  async invoke(data) {
+    return Promise.resolve(this.invokeSync(data));
+  }
+  invokeSync(data) {
+    return nunjucks.renderString(this.prompty.content, data);
+  }
+};
+var MustacheRenderer = class extends Invoker {
+  constructor() {
+    super(...arguments);
+    this.templates = {};
+  }
+  async invoke(data) {
+    return Promise.resolve(this.invokeSync(data));
+  }
+  invokeSync(data) {
+    return mustache.render(this.prompty.content, data);
+  }
+};
+var factory2 = InvokerFactory.getInstance();
+factory2.register("renderer", "jinja2", NunjucksRenderer);
+factory2.register("renderer", "mustache", MustacheRenderer);
+
+// src/core.ts
+var yaml = __toESM(require("js-yaml"));
+var ModelSettings = class {
+  constructor() {
+    this.api = "chat";
+    this.configuration = {};
+    this.parameters = {};
+    this.response = {};
+  }
+};
+var TemplateSettings = class {
+  constructor() {
+    this.type = "jinja2";
+    this.parser = "prompty";
+  }
+};
+var Prompty = class _Prompty {
+  constructor(content) {
+    // metadata
+    this.name = "";
+    this.description = "";
+    this.authors = [];
+    this.tags = [];
+    this.version = "";
+    this.base = "";
+    this.basePrompty = null;
+    // model
+    this.model = new ModelSettings();
+    // sample
+    this.sample = {};
+    // input / output
+    this.input = {};
+    this.output = {};
+    // template
+    this.template = new TemplateSettings();
+    // misc
+    this.file = "";
+    this.content = "";
+    var _a, _b, _c, _d, _e, _f;
+    const items = (0, import_gray_matter.default)(content);
+    this.name = items.data.name || "";
+    this.description = items.data.description || "";
+    this.authors = items.data.authors || [];
+    this.tags = items.data.tags || [];
+    this.version = items.data.version || "";
+    this.base = items.data.base || "";
+    this.model.api = ((_a = items.data.model) == null ? void 0 : _a.api) || "chat";
+    this.model.configuration = ((_b = items.data.model) == null ? void 0 : _b.configuration) || {};
+    this.model.parameters = ((_c = items.data.model) == null ? void 0 : _c.parameters) || {};
+    this.model.response = ((_d = items.data.model) == null ? void 0 : _d.response) || {};
+    this.sample = items.data.sample || {};
+    this.input = items.data.input || {};
+    this.output = items.data.output || {};
+    if (items.data.template && typeof items.data.template === "string") {
+      this.template.type = items.data.template || this.template.type;
+    } else {
+      this.template.type = ((_e = items.data.template) == null ? void 0 : _e.type) || this.template.type;
+      this.template.parser = ((_f = items.data.template) == null ? void 0 : _f.parser) || this.template.parser;
+    }
+    this.file = content;
+    this.content = items.content;
+  }
+  static async prepare(prompt, inputs = {}) {
+    const invoker = InvokerFactory.getInstance();
+    inputs = utils.paramHoisting(inputs, prompt.sample);
+    let render2;
+    if (prompt.template.type === "NOOP") {
+      render2 = prompt.content;
+    } else {
+      render2 = await invoker.call("renderer", prompt.template.type, prompt, inputs);
+    }
+    let result;
+    if (prompt.template.parser === "NOOP") {
+      result = render2;
+    } else {
+      result = await invoker.call("parser", `${prompt.template.parser}.${prompt.model.api}`, prompt, render2);
+    }
+    return result;
+  }
+  static async load(filePath) {
+    return new _Prompty(await utils.readFileSafe(filePath));
+  }
+  static export(prompt) {
+    const front_matter = {
+      name: prompt.name,
+      description: prompt.description,
+      authors: prompt.authors,
+      tags: prompt.tags,
+      version: prompt.version,
+      base: prompt.base,
+      model: prompt.model,
+      sample: prompt.sample,
+      input: prompt.input,
+      output: prompt.output,
+      template: prompt.template
+    };
+    const yaml_str = "---\r\n" + yaml.dump(front_matter) + "---\r\n" + prompt.content;
+    return yaml_str;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Invoker,
+  InvokerFactory,
+  Prompty
+});

package/dist/index.mjs

@@ -0,0 +1,316 @@
+// src/core.ts
+import matter from "gray-matter";
+
+// src/utils.ts
+import * as fs from "fs/promises";
+var _utils = class _utils {
+  static async readFileSafe(filePath, encoding = "utf-8") {
+    if (_utils.isNode) {
+      const data = await fs.readFile(filePath, encoding);
+      return data;
+    } else {
+      throw new Error("Load from file not supported in browser");
+    }
+  }
+  static paramHoisting(top, bottom, topKey = null) {
+    let newDict = {};
+    if (topKey) {
+      newDict = topKey in top ? { ...top[topKey] } : {};
+    } else {
+      newDict = { ...top };
+    }
+    for (const key in bottom) {
+      if (!(key in newDict)) {
+        newDict[key] = bottom[key];
+      }
+    }
+    return newDict;
+  }
+};
+_utils.isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var utils = _utils;
+
+// src/invokerFactory.ts
+var Invoker = class {
+  constructor(prompty) {
+    this.prompty = prompty;
+  }
+  async call(data) {
+    return await this.invoke(data);
+  }
+  callSync(data) {
+    return this.invokeSync(data);
+  }
+};
+var NoOpInvoker = class extends Invoker {
+  async invoke(data) {
+    return Promise.resolve(data);
+  }
+  invokeSync(data) {
+    return data;
+  }
+};
+var InvokerFactory = class _InvokerFactory {
+  constructor() {
+    this._invokers = {
+      renderer: { ["NOOP"]: NoOpInvoker },
+      parser: { ["NOOP"]: NoOpInvoker },
+      executor: { ["NOOP"]: NoOpInvoker },
+      processor: { ["NOOP"]: NoOpInvoker }
+    };
+  }
+  register(type, name, invokerClass) {
+    if (!this._invokers[type]) {
+      throw new Error(`Invalid invoker type: ${type}`);
+    }
+    this._invokers[type][name] = invokerClass;
+  }
+  create(type, name, prompty) {
+    const invokerClass = this._invokers[type][name];
+    if (!invokerClass) {
+      throw new Error(`No registered ${type} for name: ${name}`);
+    }
+    return new invokerClass(prompty);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _InvokerFactory();
+    }
+    return this._instance;
+  }
+  async call(type, name, prompty, data) {
+    return await this.create(type, name, prompty).call(data);
+  }
+  callSync(type, name, prompty, data) {
+    return this.create(type, name, prompty).callSync(data);
+  }
+  toDict() {
+    const dict = {};
+    for (const [type, invokers] of Object.entries(this._invokers)) {
+      dict[type] = Object.fromEntries(
+        Object.entries(invokers).map(([key, value]) => [key, value.name])
+      );
+    }
+    return dict;
+  }
+  toJson() {
+    return JSON.stringify(this.toDict());
+  }
+};
+
+// src/parsers.ts
+import * as path from "path";
+var PromptyChatParser = class extends Invoker {
+  constructor(prompty) {
+    super(prompty);
+    this.roles = ["assistant", "function", "system", "user"];
+  }
+  async inlineImage(imageItem) {
+    if (imageItem.startsWith("http") || imageItem.startsWith("data")) {
+      return imageItem;
+    } else {
+      if (utils.isNode) {
+        const imagePath = path.join(path.dirname(this.prompty.file), imageItem);
+        const fileContent = await utils.readFileSafe(imagePath, "base64");
+        const extension = path.extname(imagePath).toLowerCase();
+        switch (extension) {
+          case ".png":
+            return `data:image/png;base64,${fileContent}`;
+          case ".jpg":
+          case ".jpeg":
+            return `data:image/jpeg;base64,${fileContent}`;
+          default:
+            throw new Error(`Invalid image format ${extension} - currently only .png and .jpg/.jpeg are supported.`);
+        }
+      } else {
+        throw new Error("Load from file not supported in browser");
+      }
+    }
+  }
+  async parseContent(content, role) {
+    const imageRegex = /!\[(.*?)\]\((.*?)\)/gm;
+    let matches;
+    let contentItems = [];
+    let contentChunks = content.split(imageRegex);
+    for (let index = 0; index < contentChunks.length; index++) {
+      const chunk = contentChunks[index];
+      if (index % 3 === 0 && chunk.trim()) {
+        contentItems.push({ type: "text", text: chunk.trim() });
+      } else if (index % 3 === 2) {
+        const base64Str = await this.inlineImage(chunk.split(" ")[0].trim());
+        let msg = {
+          type: "image_url",
+          image_url: { url: base64Str }
+        };
+        contentItems.push(msg);
+      }
+    }
+    return contentItems;
+  }
+  invokeSync(data) {
+    throw new Error("Not Supported");
+  }
+  async invoke(data) {
+    let messages = [];
+    const separator = new RegExp(`\\s*#?\\s*(${this.roles.join("|")})\\s*:\\s*\\n`, "im");
+    let chunks = data.split(separator).filter((chunk) => chunk.trim());
+    if (!this.roles.includes(chunks[0].trim().toLowerCase())) {
+      chunks.unshift("system");
+    }
+    if (this.roles.includes(chunks[chunks.length - 1].trim().toLowerCase())) {
+      chunks.pop();
+    }
+    if (chunks.length % 2 !== 0) {
+      throw new Error("Invalid prompt format");
+    }
+    for (let i = 0; i < chunks.length; i += 2) {
+      const role = chunks[i].trim().toLowerCase();
+      const content = chunks[i + 1].trim();
+      const parsedContent = await this.parseContent(content, role);
+      messages.push({ role, content: parsedContent });
+    }
+    return messages;
+  }
+};
+var factory = InvokerFactory.getInstance();
+factory.register("parser", "prompty.chat", PromptyChatParser);
+factory.register("parser", "prompty.embedding", NoOpInvoker);
+factory.register("parser", "prompty.image", NoOpInvoker);
+factory.register("parser", "prompty.completion", NoOpInvoker);
+
+// src/renderers.ts
+import * as nunjucks from "nunjucks";
+import * as mustache from "mustache";
+var NunjucksRenderer = class extends Invoker {
+  constructor() {
+    super(...arguments);
+    this.templates = {};
+  }
+  async invoke(data) {
+    return Promise.resolve(this.invokeSync(data));
+  }
+  invokeSync(data) {
+    return nunjucks.renderString(this.prompty.content, data);
+  }
+};
+var MustacheRenderer = class extends Invoker {
+  constructor() {
+    super(...arguments);
+    this.templates = {};
+  }
+  async invoke(data) {
+    return Promise.resolve(this.invokeSync(data));
+  }
+  invokeSync(data) {
+    return mustache.render(this.prompty.content, data);
+  }
+};
+var factory2 = InvokerFactory.getInstance();
+factory2.register("renderer", "jinja2", NunjucksRenderer);
+factory2.register("renderer", "mustache", MustacheRenderer);
+
+// src/core.ts
+import * as yaml from "js-yaml";
+var ModelSettings = class {
+  constructor() {
+    this.api = "chat";
+    this.configuration = {};
+    this.parameters = {};
+    this.response = {};
+  }
+};
+var TemplateSettings = class {
+  constructor() {
+    this.type = "jinja2";
+    this.parser = "prompty";
+  }
+};
+var Prompty = class _Prompty {
+  constructor(content) {
+    // metadata
+    this.name = "";
+    this.description = "";
+    this.authors = [];
+    this.tags = [];
+    this.version = "";
+    this.base = "";
+    this.basePrompty = null;
+    // model
+    this.model = new ModelSettings();
+    // sample
+    this.sample = {};
+    // input / output
+    this.input = {};
+    this.output = {};
+    // template
+    this.template = new TemplateSettings();
+    // misc
+    this.file = "";
+    this.content = "";
+    var _a, _b, _c, _d, _e, _f;
+    const items = matter(content);
+    this.name = items.data.name || "";
+    this.description = items.data.description || "";
+    this.authors = items.data.authors || [];
+    this.tags = items.data.tags || [];
+    this.version = items.data.version || "";
+    this.base = items.data.base || "";
+    this.model.api = ((_a = items.data.model) == null ? void 0 : _a.api) || "chat";
+    this.model.configuration = ((_b = items.data.model) == null ? void 0 : _b.configuration) || {};
+    this.model.parameters = ((_c = items.data.model) == null ? void 0 : _c.parameters) || {};
+    this.model.response = ((_d = items.data.model) == null ? void 0 : _d.response) || {};
+    this.sample = items.data.sample || {};
+    this.input = items.data.input || {};
+    this.output = items.data.output || {};
+    if (items.data.template && typeof items.data.template === "string") {
+      this.template.type = items.data.template || this.template.type;
+    } else {
+      this.template.type = ((_e = items.data.template) == null ? void 0 : _e.type) || this.template.type;
+      this.template.parser = ((_f = items.data.template) == null ? void 0 : _f.parser) || this.template.parser;
+    }
+    this.file = content;
+    this.content = items.content;
+  }
+  static async prepare(prompt, inputs = {}) {
+    const invoker = InvokerFactory.getInstance();
+    inputs = utils.paramHoisting(inputs, prompt.sample);
+    let render2;
+    if (prompt.template.type === "NOOP") {
+      render2 = prompt.content;
+    } else {
+      render2 = await invoker.call("renderer", prompt.template.type, prompt, inputs);
+    }
+    let result;
+    if (prompt.template.parser === "NOOP") {
+      result = render2;
+    } else {
+      result = await invoker.call("parser", `${prompt.template.parser}.${prompt.model.api}`, prompt, render2);
+    }
+    return result;
+  }
+  static async load(filePath) {
+    return new _Prompty(await utils.readFileSafe(filePath));
+  }
+  static export(prompt) {
+    const front_matter = {
+      name: prompt.name,
+      description: prompt.description,
+      authors: prompt.authors,
+      tags: prompt.tags,
+      version: prompt.version,
+      base: prompt.base,
+      model: prompt.model,
+      sample: prompt.sample,
+      input: prompt.input,
+      output: prompt.output,
+      template: prompt.template
+    };
+    const yaml_str = "---\r\n" + yaml.dump(front_matter) + "---\r\n" + prompt.content;
+    return yaml_str;
+  }
+};
+export {
+  Invoker,
+  InvokerFactory,
+  Prompty
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@prompty/core",
+  "version": "0.1.2",
+  "description": "Prompty core package",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "npm run build -- --watch",
+    "publish-packages": "turbo run build lint test && changeset version && changeset publish --access public"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@changesets/cli": "^2.27.1",
+    "@types/base-64": "^1.0.2",
+    "@types/jest": "^29.5.12",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.11.24",
+    "@types/nunjucks": "^3.2.6",
+    "jest": "^29.7.0",
+    "puppeteer": "^22.6.4",
+    "ts-jest": "^29.1.2",
+    "tsup": "^8.0.2",
+    "typescript": "5.2.2"
+  },
+  "dependencies": {
+    "@types/mustache": "^4.2.5",
+    "base-64": "^1.0.0",
+    "gray-matter": "^4.0.3",
+    "js-yaml": "^4.1.0",
+    "mustache": "^4.2.0",
+    "nunjucks": "^3.2.4",
+    "openai": "^4.33.0"
+  }
+}