@prompty/core 0.1.4 → 2.0.0-alpha.1

package/package.json

@@ -1,51 +1,61 @@
-{
-  "name": "@prompty/core",
-  "version": "0.1.4",
-  "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.29.6",
-    "@types/base-64": "^1.0.2",
-    "@types/glob": "^8.1.0",
-    "@types/jest": "^29.5.14",
-    "@types/js-yaml": "^4.0.9",
-    "@types/mustache": "^4.2.5",
-    "@types/node": "^20.11.24",
-    "@types/nunjucks": "^3.2.6",
-    "jest": "^29.7.0",
-    "puppeteer": "^22.6.4",
-    "ts-jest": "^29.2.6",
-    "tsup": "^8.4.0",
-    "typescript": "^5.7.3"
-  },
-  "dependencies": {
-    "base-64": "^1.0.0",
-    "glob": "^11.0.1",
-    "gray-matter": "^4.0.3",
-    "js-yaml": "^4.1.1",
-    "mustache": "^4.2.0",
-    "nunjucks": "^3.2.4",
-    "openai": "^4.33.0"
-  },
-  "jest": {
-    "preset": "ts-jest",
-    "testEnvironment": "node"
-  },
-  "repository": {
-    "url": "https://github.com/microsoft/prompty"
-  }
-}
+{
+  "name": "@prompty/core",
+  "version": "2.0.0-alpha.1",
+  "description": "Prompty core runtime — load, render, parse, and trace .prompty files",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit",
+    "clean": "rimraf dist"
+  },
+  "keywords": [
+    "prompty",
+    "llm",
+    "prompt-engineering",
+    "ai"
+  ],
+  "author": "Microsoft",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/microsoft/prompty.git",
+    "directory": "runtime/typescript/packages/core"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.0",
+    "gray-matter": "^4.0.3",
+    "mustache": "^4.2.0",
+    "nunjucks": "^3.2.4",
+    "yaml": "^2.6.0"
+  },
+  "devDependencies": {
+    "@types/mustache": "^4.2.5",
+    "@types/node": "^20.11.0",
+    "@types/nunjucks": "^3.2.6",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}

package/dist/index.d.mts

@@ -1,85 +0,0 @@
-declare class PropertySettings {
-    type: string;
-    default: any;
-    description: string;
-}
-declare class ModelConfiguration {
-    type: string;
-    [key: string]: any;
-}
-declare class ModelSettings {
-    api: string;
-    configuration: ModelConfiguration;
-    parameters: any;
-    response: any;
-}
-declare class TemplateSettings {
-    type: string;
-    parser: string;
-}
-interface ExecutionOptions {
-    configuration?: any;
-    parameters?: any;
-    raw?: boolean;
-    connection?: any;
-}
-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);
-    private static _findGlobalConfig;
-    static load(filePath: string, configuration?: string): Promise<any>;
-    static prepare(prompt: Prompty, inputs?: any): Promise<any>;
-    static prepareSync(prompt: Prompty, inputs?: any): any;
-    static run(prompt: Prompty, inputs?: any, options?: ExecutionOptions): 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;
-    private static getName;
-    static getInstance(): InvokerFactory;
-    call(type: InvokerType, prompty: Prompty, data: any, alt?: any): Promise<any>;
-    callRenderer(prompty: Prompty, data: any, alt?: any): Promise<any>;
-    callParser(prompty: Prompty, data: any, alt?: any): Promise<any>;
-    callExecutor(prompty: Prompty, data: any, alt?: any): Promise<any>;
-    callProcessor(prompty: Prompty, data: any, alt?: any): Promise<any>;
-    callSync(type: InvokerType, prompty: Prompty, data: any, alt?: any): any;
-    callRendererSync(prompty: Prompty, data: any, alt?: any): any;
-    callParserSync(prompty: Prompty, data: any, alt?: any): any;
-    callExecutorSync(prompty: Prompty, data: any, alt?: any): any;
-    callProcessorSync(prompty: Prompty, data: any, alt?: any): any;
-    toDict(): Record<string, Record<string, string>>;
-    toJson(): string;
-}
-
-export { Invoker, InvokerFactory, ModelConfiguration, Prompty };

package/dist/index.mjs

@@ -1,402 +0,0 @@
-// src/core.ts
-import matter from "gray-matter";
-
-// src/utils.ts
-import * as fs from "fs/promises";
-var utils = class _utils {
-  static async importModuleSync(moduleName) {
-    const importedModule = import(moduleName);
-    return importedModule;
-  }
-  static isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-  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;
-  }
-};
-
-// src/invokerFactory.ts
-var Invoker = class {
-  prompty;
-  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 {
-  static _instance;
-  _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 getName(type, prompty) {
-    switch (type) {
-      case "renderer":
-        return prompty.template.type;
-      case "parser":
-        return `${prompty.template.parser}.${prompty.model.api}`;
-      case "executor":
-        return prompty.model.configuration.type;
-      case "processor":
-        return prompty.model.configuration.type;
-      default:
-        throw new Error(`Invalid invoker type: ${type}`);
-    }
-  }
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new _InvokerFactory();
-    }
-    return this._instance;
-  }
-  async call(type, prompty, data, alt) {
-    const name = _InvokerFactory.getName(type, prompty);
-    if (name.startsWith("NOOP") && alt) {
-      return alt;
-    } else if (name.startsWith("NOOP")) {
-      return data;
-    }
-    const invoker = this.create(type, name, prompty);
-    return await invoker.call(data);
-  }
-  async callRenderer(prompty, data, alt) {
-    return await this.call("renderer", prompty, data, alt);
-  }
-  async callParser(prompty, data, alt) {
-    return await this.call("parser", prompty, data, alt);
-  }
-  async callExecutor(prompty, data, alt) {
-    return await this.call("executor", prompty, data, alt);
-  }
-  async callProcessor(prompty, data, alt) {
-    return await this.call("processor", prompty, data, alt);
-  }
-  callSync(type, prompty, data, alt) {
-    const name = _InvokerFactory.getName(type, prompty);
-    if (name.startsWith("NOOP") && alt) {
-      return alt;
-    } else if (name.startsWith("NOOP")) {
-      return data;
-    }
-    const invoker = this.create(type, name, prompty);
-    return invoker.callSync(data);
-  }
-  callRendererSync(prompty, data, alt) {
-    return this.callSync("renderer", prompty, data, alt);
-  }
-  callParserSync(prompty, data, alt) {
-    return this.callSync("parser", prompty, data, alt);
-  }
-  callExecutorSync(prompty, data, alt) {
-    return this.callSync("executor", prompty, data, alt);
-  }
-  callProcessorSync(prompty, data, alt) {
-    return this.callSync("processor", prompty, data, alt);
-  }
-  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 {
-  roles;
-  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.replaceAll("\r\n", "\n").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);
-      if (parsedContent.length == 1 && parsedContent[0].type == "text") {
-        messages.push({ role, content: parsedContent[0].text });
-      } else {
-        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 {
-  templates = {};
-  //private name: string;
-  async invoke(data) {
-    return Promise.resolve(this.invokeSync(data));
-  }
-  invokeSync(data) {
-    return nunjucks.renderString(this.prompty.content, data);
-  }
-};
-var MustacheRenderer = class extends Invoker {
-  templates = {};
-  //private name: string;
-  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";
-import path2 from "path";
-import { glob } from "glob";
-var ModelConfiguration = class {
-  type = "unknown";
-};
-var ModelSettings = class {
-  api = "chat";
-  configuration = { type: "unknown" };
-  parameters = {};
-  response = {};
-};
-var TemplateSettings = class {
-  type = "jinja2";
-  parser = "prompty";
-};
-var Prompty = class _Prompty {
-  // metadata
-  name = "";
-  description = "";
-  authors = [];
-  tags = [];
-  version = "";
-  base = "";
-  basePrompty;
-  // model
-  model = new ModelSettings();
-  // sample
-  sample = {};
-  // input / output
-  input = {};
-  output = {};
-  // template
-  template = new TemplateSettings();
-  // misc
-  file = "";
-  content = "";
-  constructor(content) {
-    const items = matter(content, {
-      engines: {
-        yaml: {
-          parse: (input) => yaml.load(input)
-        },
-        js: {
-          parse: (input) => {
-            console.log("JS execution disabled");
-            return {};
-          }
-        }
-      }
-    });
-    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 = items.data.model?.api || "chat";
-    this.model.configuration = items.data.model?.configuration || {};
-    this.model.parameters = items.data.model?.parameters || {};
-    this.model.response = items.data.model?.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 = items.data.template?.type || this.template.type;
-      this.template.parser = items.data.template?.parser || this.template.parser;
-    }
-    this.file = content;
-    this.content = items.content;
-  }
-  static async _findGlobalConfig(promptyPath) {
-    const configs = await glob("**/prompty.json", {
-      cwd: process.cwd()
-    });
-    const filtered = configs.map((c) => path2.resolve(c)).filter((config) => config.length <= promptyPath.length).sort((a, b) => a.length - b.length);
-    if (filtered.length > 0) {
-      return filtered[filtered.length - 1];
-    } else {
-      return void 0;
-    }
-  }
-  static async load(filePath, configuration = "default") {
-    filePath = path2.resolve(filePath);
-    const p = new _Prompty(await utils.readFileSafe(filePath));
-    const c = await _Prompty._findGlobalConfig(filePath);
-    p.file = filePath;
-    return p;
-  }
-  static async prepare(prompt, inputs = {}) {
-    const invoker = InvokerFactory.getInstance();
-    inputs = utils.paramHoisting(inputs, prompt.sample);
-    const render2 = await invoker.callRenderer(prompt, inputs, prompt.content);
-    const result = await invoker.callParser(prompt, render2);
-    return result;
-  }
-  static prepareSync(prompt, inputs = {}) {
-    const invoker = InvokerFactory.getInstance();
-    inputs = utils.paramHoisting(inputs, prompt.sample);
-    const render2 = invoker.callRendererSync(prompt, inputs, prompt.content);
-    const result = invoker.callParserSync(prompt, render2);
-    return result;
-  }
-  static async run(prompt, inputs = {}, options = {}) {
-    const invoker = InvokerFactory.getInstance();
-    inputs = utils.paramHoisting(inputs, prompt.sample);
-    return {};
-  }
-  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,
-  ModelConfiguration,
-  Prompty
-};