promptopskit 0.3.4 → 0.3.6

package/dist/index.cjs

@@ -253,7 +253,10 @@ var HistorySchema = import_zod.z.object({
 });
 var ContextInputDefinitionObjectSchema = import_zod.z.object({
   name: import_zod.z.string(),
-  max_size: import_zod.z.number().int().positive().optional()
+  max_size: import_zod.z.number().int().positive().optional(),
+  trim: import_zod.z.union([import_zod.z.boolean(), import_zod.z.enum(["start", "end", "both"])]).optional(),
+  allow_regex: import_zod.z.string().optional(),
+  deny_regex: import_zod.z.string().optional()
 });
 var ContextInputDefinitionSchema = import_zod.z.union([
   import_zod.z.string(),
@@ -507,14 +510,24 @@ async function resolveIncludes(asset, basePath, visited = /* @__PURE__ */ new Se
 }
 
 // src/prompt-resolution.ts
+var DEFAULT_PROMPTS_DIR = "./prompts";
+var DEFAULT_COMPILED_JSON_DIR = "./.generated-prompts/json";
+function withPromptResolutionDefaults(config) {
+  return {
+    ...config,
+    sourceDir: config.sourceDir ?? DEFAULT_PROMPTS_DIR,
+    compiledDir: config.compiledDir ?? DEFAULT_COMPILED_JSON_DIR
+  };
+}
 var sharedPromptCache = new PromptCache();
 async function loadPromptAsset(promptPath, config, promptCache = sharedPromptCache) {
-  const mode = config.mode ?? "auto";
-  if (mode !== "source-only" && config.compiledDir) {
-    const compiledFile = (0, import_node_path3.resolve)(config.compiledDir, promptPath + ".json");
+  const resolvedConfig = withPromptResolutionDefaults(config);
+  const mode = resolvedConfig.mode ?? "auto";
+  if (mode !== "source-only" && resolvedConfig.compiledDir) {
+    const compiledFile = (0, import_node_path3.resolve)(resolvedConfig.compiledDir, promptPath + ".json");
     if ((0, import_node_fs2.existsSync)(compiledFile)) {
       if (mode === "auto") {
-        const sourceFile = (0, import_node_path3.resolve)(config.sourceDir, promptPath + ".md");
+        const sourceFile = (0, import_node_path3.resolve)(resolvedConfig.sourceDir, promptPath + ".md");
         if ((0, import_node_fs2.existsSync)(sourceFile)) {
           const compiledMtime = (0, import_node_fs2.statSync)(compiledFile).mtimeMs;
           const sourceMtime = (0, import_node_fs2.statSync)(sourceFile).mtimeMs;
@@ -537,8 +550,8 @@ Run "promptopskit compile" to generate it.`
     }
   }
   if (mode !== "compiled-only") {
-    const sourceFile = (0, import_node_path3.resolve)(config.sourceDir, promptPath + ".md");
-    if (config.cache !== false) {
+    const sourceFile = (0, import_node_path3.resolve)(resolvedConfig.sourceDir, promptPath + ".md");
+    if (resolvedConfig.cache !== false) {
       const cached = promptCache.get(sourceFile);
       if (cached) {
         return cached;
@@ -546,8 +559,8 @@ Run "promptopskit compile" to generate it.`
     }
     if (!(0, import_node_fs2.existsSync)(sourceFile)) {
       const paths = [sourceFile];
-      if (config.compiledDir) {
-        paths.unshift((0, import_node_path3.resolve)(config.compiledDir, promptPath + ".json"));
+      if (resolvedConfig.compiledDir) {
+        paths.unshift((0, import_node_path3.resolve)(resolvedConfig.compiledDir, promptPath + ".json"));
       }
       throw new Error(
         `Prompt not found: "${promptPath}"
@@ -555,8 +568,8 @@ Searched:
 ${paths.map((candidate) => `  - ${candidate}`).join("\n")}`
       );
     }
-    const { asset } = await loadPromptFile(sourceFile, { defaultsRoot: config.sourceDir });
-    if (config.cache !== false) {
+    const { asset } = await loadPromptFile(sourceFile, { defaultsRoot: resolvedConfig.sourceDir });
+    if (resolvedConfig.cache !== false) {
       promptCache.set(sourceFile, asset);
     }
     return asset;
@@ -564,8 +577,9 @@ ${paths.map((candidate) => `  - ${candidate}`).join("\n")}`
   throw new Error(`Prompt not found: "${promptPath}"`);
 }
 async function resolvePromptAsset(promptPath, config, options = {}, promptCache = sharedPromptCache) {
-  let asset = await loadPromptAsset(promptPath, config, promptCache);
-  const sourceFile = (0, import_node_path3.resolve)(config.sourceDir, promptPath + ".md");
+  const resolvedConfig = withPromptResolutionDefaults(config);
+  let asset = await loadPromptAsset(promptPath, resolvedConfig, promptCache);
+  const sourceFile = (0, import_node_path3.resolve)(resolvedConfig.sourceDir, promptPath + ".md");
   if (asset.includes && asset.includes.length > 0 && (0, import_node_fs2.existsSync)(sourceFile)) {
     asset = await resolveIncludes(asset, sourceFile);
   }
@@ -585,9 +599,142 @@ function resolveInlinePromptSource(source, options = {}) {
   });
 }
 
+// src/context.ts
+var textEncoder = new TextEncoder();
+function getContextInputs(asset) {
+  return (asset.context?.inputs ?? []).map(normalizeContextInput);
+}
+function getContextInputNames(asset) {
+  return getContextInputs(asset).map((input) => input.name);
+}
+function normalizeContextInput(input) {
+  if (typeof input === "string") {
+    return { name: input };
+  }
+  return {
+    name: input.name,
+    max_size: input.max_size,
+    trim: input.trim,
+    allow_regex: input.allow_regex,
+    deny_regex: input.deny_regex
+  };
+}
+function isTrimEnabled(mode) {
+  return mode === true || mode === "start" || mode === "end" || mode === "both";
+}
+function normalizeTrimMode(mode) {
+  if (mode === "start") {
+    return "start";
+  }
+  return "end";
+}
+function trimToMaxSize(value, maxSize, mode) {
+  const measured = measureContextValueSize(value);
+  if (measured <= maxSize) {
+    return value;
+  }
+  const characters = Array.from(value);
+  const normalizedMode = normalizeTrimMode(mode);
+  if (normalizedMode === "start") {
+    let collected2 = "";
+    let size2 = 0;
+    for (let i = characters.length - 1; i >= 0; i -= 1) {
+      const next = characters[i];
+      const charSize = measureContextValueSize(next);
+      if (size2 + charSize > maxSize) {
+        break;
+      }
+      collected2 = next + collected2;
+      size2 += charSize;
+    }
+    return collected2;
+  }
+  let collected = "";
+  let size = 0;
+  for (const char of characters) {
+    const charSize = measureContextValueSize(char);
+    if (size + charSize > maxSize) {
+      break;
+    }
+    collected += char;
+    size += charSize;
+  }
+  return collected;
+}
+function sanitizeContextVariables(asset, variables = {}, options = {}) {
+  const { onContextOverflow } = options;
+  const sanitized = { ...variables };
+  for (const input of getContextInputs(asset)) {
+    const value = sanitized[input.name];
+    if (value === void 0) {
+      continue;
+    }
+    let candidate = value;
+    if (input.max_size !== void 0) {
+      const actualSize = measureContextValueSize(candidate);
+      if (actualSize > input.max_size && onContextOverflow) {
+        candidate = onContextOverflow({
+          promptId: asset.id,
+          variable: input.name,
+          value: candidate,
+          maxSize: input.max_size,
+          actualSize
+        });
+      }
+    }
+    if (isTrimEnabled(input.trim) && input.max_size !== void 0) {
+      candidate = trimToMaxSize(candidate, input.max_size, input.trim);
+    }
+    sanitized[input.name] = candidate;
+    if (input.allow_regex) {
+      const candidate2 = sanitized[input.name];
+      const matcher = new RegExp(input.allow_regex);
+      if (!matcher.test(candidate2)) {
+        throw new Error(
+          `POK031: Context variable "${input.name}" failed allow_regex validation for prompt "${asset.id}".`
+        );
+      }
+    }
+    if (input.deny_regex) {
+      const candidate2 = sanitized[input.name];
+      const matcher = new RegExp(input.deny_regex);
+      if (matcher.test(candidate2)) {
+        throw new Error(
+          `POK032: Context variable "${input.name}" matched deny_regex for prompt "${asset.id}".`
+        );
+      }
+    }
+  }
+  return sanitized;
+}
+function measureContextValueSize(value) {
+  return textEncoder.encode(value).length;
+}
+function collectContextSizeWarnings(asset, variables = {}) {
+  const warnings = [];
+  for (const input of getContextInputs(asset)) {
+    if (input.max_size === void 0) {
+      continue;
+    }
+    const value = variables[input.name];
+    if (value === void 0) {
+      continue;
+    }
+    const actualSize = measureContextValueSize(value);
+    if (actualSize > input.max_size) {
+      warnings.push({
+        variable: input.name,
+        maxSize: input.max_size,
+        actualSize
+      });
+    }
+  }
+  return warnings;
+}
+
 // src/providers/prompt-input.ts
 function isPromptLookup(input) {
-  return "path" in input && typeof input.path === "string" && "sourceDir" in input;
+  return "path" in input && typeof input.path === "string";
 }
 function isInlinePromptSource(input) {
   return "source" in input && typeof input.source === "string";
@@ -608,7 +755,13 @@ function withPromptInputSupport(adapter) {
   };
   const renderPrompt2 = async (input, runtime) => {
     const resolved = await resolveProviderPromptInput(input, runtime);
-    return adapter.render(resolved, runtime);
+    const variables = sanitizeContextVariables(resolved, runtime.variables, {
+      onContextOverflow: runtime.onContextOverflow
+    });
+    return adapter.render(resolved, {
+      ...runtime,
+      variables
+    });
   };
   return {
     ...adapter,
@@ -895,48 +1048,6 @@ function getAdapter(provider) {
   return adapter;
 }
 
-// src/context.ts
-var textEncoder = new TextEncoder();
-function getContextInputs(asset) {
-  return (asset.context?.inputs ?? []).map(normalizeContextInput);
-}
-function getContextInputNames(asset) {
-  return getContextInputs(asset).map((input) => input.name);
-}
-function normalizeContextInput(input) {
-  if (typeof input === "string") {
-    return { name: input };
-  }
-  return {
-    name: input.name,
-    max_size: input.max_size
-  };
-}
-function measureContextValueSize(value) {
-  return textEncoder.encode(value).length;
-}
-function collectContextSizeWarnings(asset, variables = {}) {
-  const warnings = [];
-  for (const input of getContextInputs(asset)) {
-    if (input.max_size === void 0) {
-      continue;
-    }
-    const value = variables[input.name];
-    if (value === void 0) {
-      continue;
-    }
-    const actualSize = measureContextValueSize(value);
-    if (actualSize > input.max_size) {
-      warnings.push({
-        variable: input.name,
-        maxSize: input.max_size,
-        actualSize
-      });
-    }
-  }
-  return warnings;
-}
-
 // src/validation/levenshtein.ts
 function levenshtein(a, b) {
   const m = a.length;
@@ -1048,6 +1159,30 @@ function validateAsset(asset, frontMatterKeys, filePath) {
       });
     }
   }
+  for (const input of getContextInputs(asset)) {
+    if (input.trim !== void 0 && input.trim !== false && input.max_size === void 0) {
+      warnings.push({
+        code: "POK014",
+        message: `Context input "${input.name}" sets trim but has no max_size; trim-to-budget will be skipped.`,
+        filePath
+      });
+    }
+    const checks = [];
+    if (input.allow_regex) checks.push({ pattern: input.allow_regex, kind: "allow_regex" });
+    if (input.deny_regex) checks.push({ pattern: input.deny_regex, kind: "deny_regex" });
+    for (const check of checks) {
+      try {
+        new RegExp(check.pattern);
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        errors.push({
+          code: "POK013",
+          message: `Invalid context ${check.kind} for "${input.name}": ${reason}`,
+          filePath
+        });
+      }
+    }
+  }
   return {
     valid: errors.length === 0,
     errors,
@@ -1481,10 +1616,11 @@ var PromptOpsKit = class {
   config;
   promptCache;
   constructor(config) {
+    const resolvedConfig = withPromptResolutionDefaults(config);
     this.config = {
-      ...config,
-      mode: config.mode ?? "auto",
-      cache: config.cache ?? true
+      ...resolvedConfig,
+      mode: resolvedConfig.mode ?? "auto",
+      cache: resolvedConfig.cache ?? true
     };
     this.promptCache = new PromptCache();
   }
@@ -1528,7 +1664,10 @@ var PromptOpsKit = class {
 ` + validation.errors.map((e) => `  - ${e}`).join("\n")
       );
     }
-    const contextSizeWarnings = collectContextSizeWarnings(resolved, options.variables).map(
+    const sanitizedVariables = sanitizeContextVariables(resolved, options.variables, {
+      onContextOverflow: options.onContextOverflow
+    });
+    const contextSizeWarnings = collectContextSizeWarnings(resolved, sanitizedVariables).map(
       (warning) => formatContextSizeWarning(resolved, warning)
     );
     const contextWarningPolicy = this.config.warnings?.contextSize;
@@ -1538,7 +1677,7 @@ var PromptOpsKit = class {
       }
     }
     const request = adapter.render(resolved, {
-      variables: options.variables,
+      variables: sanitizedVariables,
       history: options.history,
       toolRegistry: options.toolRegistry,
       strict: options.strict
@@ -1564,12 +1703,12 @@ var PromptOpsKit = class {
     this.promptCache.clear();
   }
 };
-function createPromptOpsKit(config) {
+function createPromptOpsKit(config = {}) {
   return new PromptOpsKit(config);
 }
 async function renderPrompt(options) {
   const kit = createPromptOpsKit({
-    sourceDir: options.sourceDir ?? ".",
+    sourceDir: options.sourceDir ?? DEFAULT_PROMPTS_DIR,
     cache: false,
     warnings: options.warnings
   });