promptopskit 0.3.5 → 0.3.7

package/dist/index.cjs

@@ -251,9 +251,21 @@ var ResponseSchema = import_zod.z.object({
 var HistorySchema = import_zod.z.object({
   max_items: import_zod.z.number().int().positive().optional()
 });
+var ContextRegexSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.object({
+    pattern: import_zod.z.string(),
+    flags: import_zod.z.string().optional()
+  })
+]);
 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: ContextRegexSchema.optional(),
+  deny_regex: ContextRegexSchema.optional(),
+  non_empty: import_zod.z.boolean().optional(),
+  reject_secrets: import_zod.z.boolean().optional()
 });
 var ContextInputDefinitionSchema = import_zod.z.union([
   import_zod.z.string(),
@@ -596,6 +608,248 @@ function resolveInlinePromptSource(source, options = {}) {
   });
 }
 
+// src/context.ts
+var textEncoder = new TextEncoder();
+var REJECT_SECRETS_PATTERN = "(secret|api[_-]?key|password)";
+var REJECT_SECRETS_FLAGS = "i";
+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: normalizeContextRegex(input.allow_regex),
+    deny_regex: normalizeContextRegex(input.deny_regex),
+    non_empty: input.non_empty,
+    reject_secrets: input.reject_secrets
+  };
+}
+function normalizeContextRegex(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const literal = parseRegexLiteral(value);
+    if (value.startsWith("/") && !literal) {
+      return {
+        pattern: value,
+        flags: "",
+        raw: value,
+        invalidLiteral: true
+      };
+    }
+    return {
+      pattern: literal?.pattern ?? value,
+      flags: literal?.flags ?? "",
+      raw: value
+    };
+  }
+  return {
+    pattern: value.pattern,
+    flags: value.flags ?? "",
+    raw: JSON.stringify(value)
+  };
+}
+function parseRegexLiteral(value) {
+  if (!value.startsWith("/")) {
+    return void 0;
+  }
+  for (let index = value.length - 1; index > 0; index -= 1) {
+    if (value[index] !== "/") {
+      continue;
+    }
+    let backslashCount = 0;
+    for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) {
+      backslashCount += 1;
+    }
+    if (backslashCount % 2 === 1) {
+      continue;
+    }
+    return {
+      pattern: value.slice(1, index),
+      flags: value.slice(index + 1)
+    };
+  }
+  return void 0;
+}
+function formatInvalidContextRegexMessage(details) {
+  return [
+    `Invalid context regex for prompt "${details.promptId}"`,
+    `variable "${details.variable}"`,
+    `field "${details.field}"`,
+    `value ${JSON.stringify(details.raw)}: ${details.reason}`
+  ].join(", ");
+}
+function compileContextRegex(regex, details) {
+  if (regex.invalidLiteral) {
+    throw new Error(
+      `POK013: ${formatInvalidContextRegexMessage({
+        ...details,
+        raw: regex.raw,
+        reason: "Malformed regex literal. Use /pattern/flags or { pattern, flags }."
+      })}`
+    );
+  }
+  try {
+    return new RegExp(regex.pattern, regex.flags);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`POK013: ${formatInvalidContextRegexMessage({ ...details, raw: regex.raw, reason })}`);
+  }
+}
+function getRejectSecretsRegex() {
+  return {
+    pattern: REJECT_SECRETS_PATTERN,
+    flags: REJECT_SECRETS_FLAGS,
+    raw: JSON.stringify({ pattern: REJECT_SECRETS_PATTERN, flags: REJECT_SECRETS_FLAGS })
+  };
+}
+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 = compileContextRegex(input.allow_regex, {
+        promptId: asset.id,
+        variable: input.name,
+        field: "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 = compileContextRegex(input.deny_regex, {
+        promptId: asset.id,
+        variable: input.name,
+        field: "deny_regex"
+      });
+      if (matcher.test(candidate2)) {
+        throw new Error(
+          `POK032: Context variable "${input.name}" matched deny_regex for prompt "${asset.id}".`
+        );
+      }
+    }
+    if (input.non_empty && candidate.trim().length === 0) {
+      throw new Error(
+        `POK033: Context variable "${input.name}" failed non_empty validation for prompt "${asset.id}".`
+      );
+    }
+    if (input.reject_secrets) {
+      const matcher = compileContextRegex(getRejectSecretsRegex(), {
+        promptId: asset.id,
+        variable: input.name,
+        field: "reject_secrets"
+      });
+      if (matcher.test(candidate)) {
+        throw new Error(
+          `POK034: Context variable "${input.name}" matched reject_secrets validation 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";
@@ -619,7 +873,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,
@@ -906,48 +1166,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;
@@ -1059,6 +1277,34 @@ 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({ regex: input.allow_regex, kind: "allow_regex" });
+    if (input.deny_regex) checks.push({ regex: input.deny_regex, kind: "deny_regex" });
+    for (const check of checks) {
+      try {
+        compileContextRegex(check.regex, {
+          promptId: asset.id,
+          variable: input.name,
+          field: check.kind
+        });
+      } catch (error) {
+        const reason = error instanceof Error ? error.message.replace(/^POK013:\s*/, "") : String(error);
+        errors.push({
+          code: "POK013",
+          message: reason,
+          filePath
+        });
+      }
+    }
+  }
   return {
     valid: errors.length === 0,
     errors,
@@ -1540,7 +1786,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;
@@ -1550,7 +1799,7 @@ var PromptOpsKit = class {
       }
     }
     const request = adapter.render(resolved, {
-      variables: options.variables,
+      variables: sanitizedVariables,
       history: options.history,
       toolRegistry: options.toolRegistry,
       strict: options.strict