@nudge-ai/core 0.0.1-beta.1 → 0.1.0

package/dist/nudge-yNScKCNl.cjs

@@ -0,0 +1,247 @@
+
+//#region src/create-step.ts
+/**
+* Creates a step definition that can be used to extend a builder.
+*
+* @example
+* ```ts
+* const tone = createStep({
+*   name: 'tone',
+*   build: (style: string) => ({ type: 'tone', style }),
+*   format: (step) => `[Tone] Write in a ${step.style} tone`,
+* });
+* ```
+*/
+function createStep(definition) {
+	return definition;
+}
+
+//#endregion
+//#region src/base-steps.ts
+function formatNudge(nudge$1) {
+	if (!nudge$1 || nudge$1 === 3) return "";
+	return `\nNudge: ${nudge$1}`;
+}
+const raw = createStep({
+	name: "raw",
+	build: (value) => ({
+		type: "raw",
+		value
+	}),
+	format: (step) => `[Raw Text] (Include this text verbatim in the system prompt.)\nValue: "${step.value}"`
+});
+const persona = createStep({
+	name: "persona",
+	build: (role) => ({
+		type: "persona",
+		role
+	}),
+	format: (step) => `[Persona] (Define the identity and role the AI should assume. Frame this as 'You are...' at the start of the system prompt.)\nValue: "${step.role}"`
+});
+const input = createStep({
+	name: "input",
+	build: (description) => ({
+		type: "input",
+		description
+	}),
+	format: (step) => `[Input] (Describe what input the AI will receive from the user. Help the AI understand the context of what it will be working with.)\nValue: "${step.description}"`
+});
+const output = createStep({
+	name: "output",
+	build: (description) => ({
+		type: "output",
+		description
+	}),
+	format: (step) => `[Output] (Specify what the AI should produce as output. Be clear about the expected format and content.)\nValue: "${step.description}"`
+});
+const context = createStep({
+	name: "context",
+	build: (information) => ({
+		type: "context",
+		information
+	}),
+	format: (step) => `[Context] (Background information or context that helps the AI understand the situation. This is not an instruction, just helpful information.)\nValue: "${step.information}"`
+});
+const doStep = createStep({
+	name: "do",
+	build: (instruction, options) => ({
+		type: "do",
+		instruction,
+		nudge: options?.nudge
+	}),
+	format: (step) => `[Do] (A positive instruction the AI must follow.)\nValue: "${step.instruction}"${formatNudge(step.nudge)}`
+});
+const dont = createStep({
+	name: "dont",
+	build: (instruction, options) => ({
+		type: "dont",
+		instruction,
+		nudge: options?.nudge
+	}),
+	format: (step) => `[Don't] (A negative instruction - something the AI must avoid.)\nValue: "${step.instruction}"${formatNudge(step.nudge)}`
+});
+const constraint = createStep({
+	name: "constraint",
+	build: (rule, options) => ({
+		type: "constraint",
+		rule,
+		nudge: options?.nudge
+	}),
+	format: (step) => `[Constraint] (A rule or limitation the AI must respect.)\nValue: "${step.rule}"${formatNudge(step.nudge)}`
+});
+const example = createStep({
+	name: "example",
+	build: (inputText, outputText) => ({
+		type: "example",
+		input: inputText,
+		output: outputText
+	}),
+	format: (step) => `[Example] (An input/output example showing the AI how to respond. Use these to demonstrate the expected behavior.)\nInput: "${step.input}"\nExpected output: "${step.output}"`
+});
+const baseSteps = [
+	raw,
+	persona,
+	input,
+	output,
+	context,
+	doStep,
+	dont,
+	constraint,
+	example
+];
+
+//#endregion
+//#region src/nudge.ts
+let promptCache = {};
+function registerPrompts(prompts) {
+	promptCache = {
+		...promptCache,
+		...prompts
+	};
+}
+function processTemplate(text, options = {}) {
+	const processOptionals = (str) => str.replace(/\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_, name, content) => options[name] ? processOptionals(content) : "");
+	const processVars = (str) => str.replace(/\{\{(?![#\/])(\w+)\}\}/g, (match, name) => {
+		const value = options[name];
+		return typeof value === "string" ? value : match;
+	});
+	return processVars(processOptionals(text)).replace(/\n{3,}/g, "\n\n");
+}
+const baseStepDefinitions = /* @__PURE__ */ new Map();
+for (const def of baseSteps) baseStepDefinitions.set(def.name, def);
+/** Format a step for AI consumption using the base step definitions. */
+function formatStepForAI(step) {
+	if (step.type === "optional") {
+		const opt = step;
+		const inner = opt.steps.map(formatStepForAI).join("\n\n");
+		return `[Optional Block Start: "${opt.name}"] (The following instructions are OPTIONAL. Wrap the generated content for these in {{#${opt.name}}}...{{/${opt.name}}} markers so it can be toggled at runtime.)\n\n${inner}\n\n[Optional Block End: "${opt.name}"]`;
+	}
+	const def = baseStepDefinitions.get(step.type);
+	if (!def) return `[Unknown Step: ${step.type}]`;
+	return def.format(step);
+}
+function createBuilder(customSteps = [], options = {}) {
+	const { omitBaseSteps = false } = options;
+	const allDefs = omitBaseSteps ? customSteps : [...baseSteps, ...customSteps];
+	const definitions = /* @__PURE__ */ new Map();
+	for (const def of allDefs) definitions.set(def.name, def);
+	function createPromptBuilder(state) {
+		const builder = {};
+		for (const [name, def] of definitions) builder[name] = (...args) => {
+			state.steps.push(def.build(...args));
+			return builder;
+		};
+		builder.use = (source) => {
+			state.steps.push(...source._state.steps);
+			return builder;
+		};
+		builder.optional = (name, builderFn) => {
+			const innerState = { steps: [] };
+			builderFn(createPromptBuilder(innerState));
+			state.steps.push({
+				type: "optional",
+				name,
+				steps: innerState.steps
+			});
+			return builder;
+		};
+		builder.variant = (name, builderFn) => {
+			const innerState = { steps: [] };
+			builderFn(createPromptBuilder(innerState));
+			if (!state.variants) state.variants = [];
+			state.variants.push({
+				name,
+				steps: innerState.steps
+			});
+			return builder;
+		};
+		builder.test = (input$1, assert, description) => {
+			if (!state.tests) state.tests = [];
+			state.tests.push({
+				input: input$1,
+				assert,
+				description
+			});
+			return builder;
+		};
+		return builder;
+	}
+	function formatStep(step) {
+		if (step.type === "optional") {
+			const opt = step;
+			const inner = opt.steps.map(formatStep).join("\n\n");
+			return `[Optional Block Start: "${opt.name}"] (The following instructions are OPTIONAL. Wrap the generated content for these in {{#${opt.name}}}...{{/${opt.name}}} markers so it can be toggled at runtime.)\n\n${inner}\n\n[Optional Block End: "${opt.name}"]`;
+		}
+		const def = definitions.get(step.type);
+		if (!def) return `[Unknown Step: ${step.type}]`;
+		return def.format(step);
+	}
+	return { prompt: (id, builderFn) => {
+		const state = { steps: [] };
+		builderFn(createPromptBuilder(state));
+		return {
+			id,
+			_state: state,
+			variantNames: state.variants?.map((v) => v.name) ?? [],
+			toString: ((options$1) => {
+				const cached = promptCache[id];
+				if (!cached) return "";
+				const variantName = options$1?.variant ?? "default";
+				return processTemplate(cached.variants[variantName] ?? cached.variants["default"] ?? "", options$1).trim();
+			})
+		};
+	} };
+}
+const nudge = createBuilder(baseSteps, { omitBaseSteps: true });
+
+//#endregion
+Object.defineProperty(exports, 'createBuilder', {
+  enumerable: true,
+  get: function () {
+    return createBuilder;
+  }
+});
+Object.defineProperty(exports, 'createStep', {
+  enumerable: true,
+  get: function () {
+    return createStep;
+  }
+});
+Object.defineProperty(exports, 'formatStepForAI', {
+  enumerable: true,
+  get: function () {
+    return formatStepForAI;
+  }
+});
+Object.defineProperty(exports, 'nudge', {
+  enumerable: true,
+  get: function () {
+    return nudge;
+  }
+});
+Object.defineProperty(exports, 'registerPrompts', {
+  enumerable: true,
+  get: function () {
+    return registerPrompts;
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudge-ai/core",
-  "version": "0.0.1-beta.1",
+  "version": "0.1.0",
   "description": "Core library for Nudge - type-safe prompt builder for AI applications",
   "type": "module",
   "license": "MIT",
@@ -38,6 +38,10 @@
       "require": "./dist/index.cjs",
       "import": "./dist/index.mjs"
     },
+    "./internal": {
+      "require": "./dist/internal.cjs",
+      "import": "./dist/internal.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {