promptopskit 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -0,0 +1,963 @@
+"use strict";
+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, {
+  PromptAssetOverridesSchema: () => PromptAssetOverridesSchema,
+  PromptAssetSchema: () => PromptAssetSchema,
+  PromptOpsKit: () => PromptOpsKit,
+  anthropicAdapter: () => anthropicAdapter,
+  applyOverrides: () => applyOverrides,
+  createPromptOpsKit: () => createPromptOpsKit,
+  extractSections: () => extractSections,
+  extractVariables: () => extractVariables,
+  geminiAdapter: () => geminiAdapter,
+  getAdapter: () => getAdapter,
+  interpolate: () => interpolate,
+  loadPromptFile: () => loadPromptFile,
+  openaiAdapter: () => openaiAdapter,
+  openrouterAdapter: () => openrouterAdapter,
+  parsePrompt: () => parsePrompt,
+  renderPrompt: () => renderPrompt,
+  resolveIncludes: () => resolveIncludes,
+  validateAsset: () => validateAsset,
+  validateAssetWithIncludes: () => validateAssetWithIncludes
+});
+module.exports = __toCommonJS(src_exports);
+var import_promises3 = require("fs/promises");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+
+// src/parser/parser.ts
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+
+// src/schema/schema.ts
+var import_zod = require("zod");
+var InlineToolDefSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  input_schema: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+var ToolRefSchema = import_zod.z.union([import_zod.z.string(), InlineToolDefSchema]);
+var MCPServerRefSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.object({
+    name: import_zod.z.string(),
+    config: import_zod.z.record(import_zod.z.unknown()).optional()
+  })
+]);
+var ReasoningSchema = import_zod.z.object({
+  effort: import_zod.z.enum(["low", "medium", "high"]).optional(),
+  budget_tokens: import_zod.z.number().int().positive().optional()
+});
+var SamplingSchema = import_zod.z.object({
+  temperature: import_zod.z.number().min(0).max(2).optional(),
+  top_p: import_zod.z.number().min(0).max(1).optional(),
+  frequency_penalty: import_zod.z.number().optional(),
+  presence_penalty: import_zod.z.number().optional(),
+  stop: import_zod.z.array(import_zod.z.string()).optional(),
+  max_output_tokens: import_zod.z.number().int().positive().optional()
+});
+var ResponseSchema = import_zod.z.object({
+  format: import_zod.z.enum(["text", "json", "markdown"]).optional(),
+  stream: import_zod.z.boolean().optional()
+});
+var HistorySchema = import_zod.z.object({
+  max_items: import_zod.z.number().int().positive().optional()
+});
+var ContextSchema = import_zod.z.object({
+  inputs: import_zod.z.array(import_zod.z.string()).optional(),
+  history: HistorySchema.optional()
+});
+var MetadataSchema = import_zod.z.object({
+  owner: import_zod.z.string().optional(),
+  tags: import_zod.z.array(import_zod.z.string()).optional(),
+  review_required: import_zod.z.boolean().optional(),
+  stable: import_zod.z.boolean().optional()
+});
+var MCPSchema = import_zod.z.object({
+  servers: import_zod.z.array(MCPServerRefSchema).optional()
+});
+var PromptAssetOverridesSchema = import_zod.z.object({
+  model: import_zod.z.string().optional(),
+  fallback_models: import_zod.z.array(import_zod.z.string()).optional(),
+  reasoning: ReasoningSchema.optional(),
+  sampling: SamplingSchema.optional(),
+  response: ResponseSchema.optional(),
+  tools: import_zod.z.array(ToolRefSchema).optional()
+});
+var SourceSchema = import_zod.z.object({
+  file_path: import_zod.z.string().optional(),
+  checksum: import_zod.z.string().optional()
+});
+var SectionsSchema = import_zod.z.object({
+  system_instructions: import_zod.z.string().optional(),
+  prompt_template: import_zod.z.string().optional(),
+  notes: import_zod.z.string().optional()
+});
+var PromptAssetSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  schema_version: import_zod.z.number().int().positive().default(1),
+  description: import_zod.z.string().optional(),
+  provider: import_zod.z.enum(["openai", "anthropic", "google", "gemini", "openrouter", "any"]).optional(),
+  model: import_zod.z.string().optional(),
+  fallback_models: import_zod.z.array(import_zod.z.string()).optional(),
+  reasoning: ReasoningSchema.optional(),
+  sampling: SamplingSchema.optional(),
+  response: ResponseSchema.optional(),
+  tools: import_zod.z.array(ToolRefSchema).optional(),
+  mcp: MCPSchema.optional(),
+  context: ContextSchema.optional(),
+  includes: import_zod.z.array(import_zod.z.string()).optional(),
+  environments: import_zod.z.record(PromptAssetOverridesSchema).optional(),
+  tiers: import_zod.z.record(PromptAssetOverridesSchema).optional(),
+  metadata: MetadataSchema.optional(),
+  // Populated by parser, not authored in YAML
+  sections: SectionsSchema.optional(),
+  source: SourceSchema.optional()
+});
+
+// src/parser/sections.ts
+var SECTION_MAP = {
+  "system instructions": "system_instructions",
+  "prompt template": "prompt_template",
+  "notes": "notes"
+};
+function extractSections(body) {
+  const lines = body.split("\n");
+  const sections = {};
+  let currentKey = null;
+  let currentLines = [];
+  let foundAnyH1 = false;
+  for (const line of lines) {
+    const h1Match = line.match(/^#\s+(.+)$/);
+    if (h1Match) {
+      if (currentKey) {
+        sections[currentKey] = currentLines.join("\n").trim();
+      }
+      foundAnyH1 = true;
+      const heading = h1Match[1].trim().toLowerCase();
+      currentKey = SECTION_MAP[heading] ?? null;
+      currentLines = [];
+    } else {
+      currentLines.push(line);
+    }
+  }
+  if (currentKey) {
+    sections[currentKey] = currentLines.join("\n").trim();
+  }
+  if (!foundAnyH1) {
+    const trimmed = body.trim();
+    if (trimmed) {
+      sections.prompt_template = trimmed;
+    }
+  }
+  return sections;
+}
+
+// src/parser/parser.ts
+function parsePrompt(content, filePath) {
+  const { data: frontMatter, content: body } = (0, import_gray_matter.default)(content);
+  const sections = extractSections(body);
+  const raw = {
+    ...frontMatter,
+    sections,
+    source: filePath ? { file_path: filePath } : void 0
+  };
+  const asset = PromptAssetSchema.parse(raw);
+  return {
+    asset,
+    raw: {
+      frontMatter,
+      body
+    }
+  };
+}
+
+// src/parser/loader.ts
+var import_promises = require("fs/promises");
+async function loadPromptFile(filePath) {
+  const content = await (0, import_promises.readFile)(filePath, "utf-8");
+  return parsePrompt(content, filePath);
+}
+
+// src/composition/resolve-includes.ts
+var import_promises2 = require("fs/promises");
+var import_node_path = require("path");
+async function resolveIncludes(asset, basePath, visited = /* @__PURE__ */ new Set()) {
+  if (!asset.includes || asset.includes.length === 0) {
+    return asset;
+  }
+  const baseDir = (0, import_node_path.dirname)(basePath);
+  const resolvedPath = (0, import_node_path.resolve)(basePath);
+  if (visited.has(resolvedPath)) {
+    throw new Error(`Circular include detected: ${resolvedPath}`);
+  }
+  visited.add(resolvedPath);
+  let mergedSystemInstructions = "";
+  for (const includePath of asset.includes) {
+    const fullPath = (0, import_node_path.resolve)(baseDir, includePath);
+    if (visited.has(fullPath)) {
+      throw new Error(`Circular include detected: ${fullPath} (included from ${basePath})`);
+    }
+    const content = await (0, import_promises2.readFile)(fullPath, "utf-8");
+    const { asset: includedAsset } = parsePrompt(content, fullPath);
+    const resolved = await resolveIncludes(includedAsset, fullPath, new Set(visited));
+    if (resolved.sections?.system_instructions) {
+      mergedSystemInstructions += resolved.sections.system_instructions + "\n\n";
+    }
+  }
+  const localSystem = asset.sections?.system_instructions ?? "";
+  const combinedSystem = (mergedSystemInstructions + localSystem).trim() || void 0;
+  return {
+    ...asset,
+    sections: {
+      ...asset.sections,
+      system_instructions: combinedSystem
+    },
+    // Drop includes from the resolved asset — they've been inlined
+    includes: void 0
+  };
+}
+
+// src/overrides/apply-overrides.ts
+function applyOverrides(asset, options = {}) {
+  let result = { ...asset };
+  if (options.environment && result.environments?.[options.environment]) {
+    result = mergeOverride(result, result.environments[options.environment]);
+  }
+  if (options.tier && result.tiers?.[options.tier]) {
+    result = mergeOverride(result, result.tiers[options.tier]);
+  }
+  if (options.runtime) {
+    result = mergeOverride(result, options.runtime);
+  }
+  return result;
+}
+function mergeOverride(base, override) {
+  const result = { ...base };
+  if (override.model !== void 0) result.model = override.model;
+  if (override.fallback_models !== void 0) result.fallback_models = override.fallback_models;
+  if (override.tools !== void 0) result.tools = override.tools;
+  if (override.reasoning !== void 0) {
+    result.reasoning = { ...result.reasoning, ...override.reasoning };
+  }
+  if (override.sampling !== void 0) {
+    result.sampling = { ...result.sampling, ...override.sampling };
+  }
+  if (override.response !== void 0) {
+    result.response = { ...result.response, ...override.response };
+  }
+  return result;
+}
+
+// src/renderer/interpolate.ts
+var VARIABLE_RE = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g;
+var ESCAPED_OPEN = /\\\{\\\{/g;
+var ESCAPE_PLACEHOLDER = "\0ESCAPED_OPEN\0";
+function interpolate(template, variables, options = {}) {
+  const { strict = false } = options;
+  let result = template.replace(ESCAPED_OPEN, ESCAPE_PLACEHOLDER);
+  result = result.replace(VARIABLE_RE, (match, name) => {
+    if (name in variables) {
+      return variables[name];
+    }
+    if (strict) {
+      throw new Error(`Missing required variable: "${name}"`);
+    }
+    return match;
+  });
+  result = result.replaceAll(ESCAPE_PLACEHOLDER, "{{");
+  return result;
+}
+function extractVariables(template) {
+  const vars = /* @__PURE__ */ new Set();
+  let match;
+  const re = new RegExp(VARIABLE_RE.source, "g");
+  while ((match = re.exec(template)) !== null) {
+    vars.add(match[1]);
+  }
+  return [...vars];
+}
+
+// src/renderer/renderer.ts
+function renderSections(asset, options = {}) {
+  const { variables = {}, strict = false } = options;
+  const result = {};
+  if (asset.sections.system_instructions) {
+    result.system_instructions = interpolate(
+      asset.sections.system_instructions,
+      variables,
+      { strict }
+    );
+  }
+  if (asset.sections.prompt_template) {
+    result.prompt_template = interpolate(
+      asset.sections.prompt_template,
+      variables,
+      { strict }
+    );
+  }
+  return result;
+}
+
+// src/providers/openai.ts
+var openaiAdapter = {
+  name: "openai",
+  validate(asset) {
+    const errors = [];
+    const warnings = [];
+    if (!asset.model) {
+      errors.push("OpenAI adapter requires a model to be specified.");
+    }
+    if (asset.reasoning?.budget_tokens !== void 0) {
+      warnings.push("OpenAI uses reasoning_effort, not budget_tokens. budget_tokens will be ignored.");
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  },
+  render(asset, runtime) {
+    const sections = renderSections(asset, {
+      variables: runtime.variables,
+      strict: runtime.strict
+    });
+    const messages = [];
+    if (sections.system_instructions) {
+      messages.push({ role: "system", content: sections.system_instructions });
+    }
+    if (runtime.history) {
+      for (const msg of runtime.history) {
+        messages.push({ role: msg.role, content: msg.content });
+      }
+    }
+    if (sections.prompt_template) {
+      messages.push({ role: "user", content: sections.prompt_template });
+    }
+    const body = {
+      model: asset.model,
+      messages
+    };
+    if (asset.sampling?.temperature !== void 0) body.temperature = asset.sampling.temperature;
+    if (asset.sampling?.top_p !== void 0) body.top_p = asset.sampling.top_p;
+    if (asset.sampling?.frequency_penalty !== void 0) body.frequency_penalty = asset.sampling.frequency_penalty;
+    if (asset.sampling?.presence_penalty !== void 0) body.presence_penalty = asset.sampling.presence_penalty;
+    if (asset.sampling?.stop !== void 0) body.stop = asset.sampling.stop;
+    if (asset.sampling?.max_output_tokens !== void 0) body.max_tokens = asset.sampling.max_output_tokens;
+    if (asset.reasoning?.effort) {
+      body.reasoning_effort = asset.reasoning.effort;
+    }
+    if (asset.response?.format === "json") {
+      body.response_format = { type: "json_object" };
+    }
+    if (asset.response?.stream !== void 0) {
+      body.stream = asset.response.stream;
+    }
+    if (asset.tools && asset.tools.length > 0) {
+      body.tools = asset.tools.map((tool) => {
+        if (typeof tool === "string") {
+          const def = runtime.toolRegistry?.[tool];
+          if (def) return def;
+          return { type: "function", function: { name: tool } };
+        }
+        return {
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema
+          }
+        };
+      });
+    }
+    return {
+      body,
+      provider: "openai",
+      model: asset.model ?? "unknown"
+    };
+  }
+};
+
+// src/providers/anthropic.ts
+var anthropicAdapter = {
+  name: "anthropic",
+  validate(asset) {
+    const errors = [];
+    const warnings = [];
+    if (!asset.model) {
+      errors.push("Anthropic adapter requires a model to be specified.");
+    }
+    if (asset.sampling?.frequency_penalty !== void 0) {
+      warnings.push("Anthropic does not support frequency_penalty. It will be ignored.");
+    }
+    if (asset.sampling?.presence_penalty !== void 0) {
+      warnings.push("Anthropic does not support presence_penalty. It will be ignored.");
+    }
+    if (asset.reasoning?.effort !== void 0) {
+      warnings.push("Anthropic uses budget_tokens for thinking, not effort. effort will be mapped approximately.");
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  },
+  render(asset, runtime) {
+    const sections = renderSections(asset, {
+      variables: runtime.variables,
+      strict: runtime.strict
+    });
+    const messages = [];
+    if (runtime.history) {
+      for (const msg of runtime.history) {
+        messages.push({ role: msg.role, content: msg.content });
+      }
+    }
+    if (sections.prompt_template) {
+      messages.push({ role: "user", content: sections.prompt_template });
+    }
+    const body = {
+      model: asset.model,
+      messages
+    };
+    if (sections.system_instructions) {
+      body.system = sections.system_instructions;
+    }
+    if (asset.sampling?.temperature !== void 0) body.temperature = asset.sampling.temperature;
+    if (asset.sampling?.top_p !== void 0) body.top_p = asset.sampling.top_p;
+    if (asset.sampling?.stop !== void 0) body.stop_sequences = asset.sampling.stop;
+    if (asset.sampling?.max_output_tokens !== void 0) {
+      body.max_tokens = asset.sampling.max_output_tokens;
+    } else {
+      body.max_tokens = 4096;
+    }
+    if (asset.reasoning?.budget_tokens) {
+      body.thinking = {
+        type: "enabled",
+        budget_tokens: asset.reasoning.budget_tokens
+      };
+    }
+    if (asset.response?.stream !== void 0) {
+      body.stream = asset.response.stream;
+    }
+    if (asset.tools && asset.tools.length > 0) {
+      body.tools = asset.tools.map((tool) => {
+        if (typeof tool === "string") {
+          const def = runtime.toolRegistry?.[tool];
+          if (def) return def;
+          return { name: tool };
+        }
+        return {
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.input_schema ?? { type: "object", properties: {} }
+        };
+      });
+    }
+    return {
+      body,
+      provider: "anthropic",
+      model: asset.model ?? "unknown"
+    };
+  }
+};
+
+// src/providers/gemini.ts
+var geminiAdapter = {
+  name: "gemini",
+  validate(asset) {
+    const errors = [];
+    const warnings = [];
+    if (!asset.model) {
+      errors.push("Gemini adapter requires a model to be specified.");
+    }
+    if (asset.sampling?.frequency_penalty !== void 0) {
+      warnings.push("Gemini does not support frequency_penalty. It will be ignored.");
+    }
+    if (asset.sampling?.presence_penalty !== void 0) {
+      warnings.push("Gemini does not support presence_penalty. It will be ignored.");
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  },
+  render(asset, runtime) {
+    const sections = renderSections(asset, {
+      variables: runtime.variables,
+      strict: runtime.strict
+    });
+    const contents = [];
+    if (runtime.history) {
+      for (const msg of runtime.history) {
+        contents.push({
+          role: msg.role === "assistant" ? "model" : "user",
+          parts: [{ text: msg.content }]
+        });
+      }
+    }
+    if (sections.prompt_template) {
+      contents.push({
+        role: "user",
+        parts: [{ text: sections.prompt_template }]
+      });
+    }
+    const body = {
+      contents
+    };
+    if (sections.system_instructions) {
+      body.systemInstruction = {
+        parts: [{ text: sections.system_instructions }]
+      };
+    }
+    const generationConfig = {};
+    if (asset.sampling?.temperature !== void 0) generationConfig.temperature = asset.sampling.temperature;
+    if (asset.sampling?.top_p !== void 0) generationConfig.topP = asset.sampling.top_p;
+    if (asset.sampling?.max_output_tokens !== void 0) generationConfig.maxOutputTokens = asset.sampling.max_output_tokens;
+    if (asset.sampling?.stop !== void 0) generationConfig.stopSequences = asset.sampling.stop;
+    if (asset.response?.format === "json") {
+      generationConfig.responseMimeType = "application/json";
+    }
+    if (asset.reasoning?.effort) {
+      body.thinkingConfig = {
+        thinkingBudget: asset.reasoning.effort === "high" ? 8192 : asset.reasoning.effort === "medium" ? 4096 : 1024
+      };
+    }
+    if (Object.keys(generationConfig).length > 0) {
+      body.generationConfig = generationConfig;
+    }
+    if (asset.tools && asset.tools.length > 0) {
+      const functionDeclarations = asset.tools.map((tool) => {
+        if (typeof tool === "string") {
+          const def = runtime.toolRegistry?.[tool];
+          if (def) return def;
+          return { name: tool };
+        }
+        return {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.input_schema
+        };
+      });
+      body.tools = [{ functionDeclarations }];
+    }
+    return {
+      body,
+      provider: "gemini",
+      model: asset.model ?? "unknown"
+    };
+  }
+};
+
+// src/providers/openrouter.ts
+var openrouterAdapter = {
+  name: "openrouter",
+  validate(asset) {
+    return openaiAdapter.validate(asset);
+  },
+  render(asset, runtime) {
+    const result = openaiAdapter.render(asset, runtime);
+    return {
+      ...result,
+      provider: "openrouter"
+    };
+  }
+};
+
+// src/providers/index.ts
+var adapters = {
+  openai: openaiAdapter,
+  anthropic: anthropicAdapter,
+  google: geminiAdapter,
+  gemini: geminiAdapter,
+  openrouter: openrouterAdapter
+};
+function getAdapter(provider) {
+  const adapter = adapters[provider];
+  if (!adapter) {
+    throw new Error(
+      `Unknown provider: "${provider}". Supported: ${Object.keys(adapters).join(", ")}`
+    );
+  }
+  return adapter;
+}
+
+// src/validation/levenshtein.ts
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[m][n];
+}
+
+// src/validation/validate.ts
+var KNOWN_FRONT_MATTER_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "schema_version",
+  "description",
+  "provider",
+  "model",
+  "fallback_models",
+  "reasoning",
+  "sampling",
+  "response",
+  "tools",
+  "mcp",
+  "context",
+  "includes",
+  "environments",
+  "tiers",
+  "metadata"
+]);
+function validateAsset(asset, frontMatterKeys, filePath) {
+  const errors = [];
+  const warnings = [];
+  const result = PromptAssetSchema.safeParse(asset);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      errors.push({
+        code: "POK001",
+        message: `Schema error at ${issue.path.join(".")}: ${issue.message}`,
+        filePath
+      });
+    }
+  }
+  if (!asset.id) {
+    errors.push({
+      code: "POK002",
+      message: 'Missing required field: "id"',
+      filePath
+    });
+  }
+  if (!asset.sections?.system_instructions && !asset.sections?.prompt_template) {
+    errors.push({
+      code: "POK003",
+      message: "Prompt must have at least one body section (System instructions or Prompt template)",
+      filePath
+    });
+  }
+  if (frontMatterKeys) {
+    for (const key of frontMatterKeys) {
+      if (!KNOWN_FRONT_MATTER_KEYS.has(key)) {
+        const suggestion = findClosestMatch(key, KNOWN_FRONT_MATTER_KEYS);
+        warnings.push({
+          code: "POK010",
+          message: `Unknown front matter field: "${key}"`,
+          filePath,
+          suggestion: suggestion ? `Did you mean "${suggestion}"?` : void 0
+        });
+      }
+    }
+  }
+  const declaredInputs = new Set(asset.context?.inputs ?? []);
+  const usedVars = /* @__PURE__ */ new Set();
+  if (asset.sections?.system_instructions) {
+    for (const v of extractVariables(asset.sections.system_instructions)) {
+      usedVars.add(v);
+    }
+  }
+  if (asset.sections?.prompt_template) {
+    for (const v of extractVariables(asset.sections.prompt_template)) {
+      usedVars.add(v);
+    }
+  }
+  for (const v of usedVars) {
+    if (declaredInputs.size > 0 && !declaredInputs.has(v)) {
+      warnings.push({
+        code: "POK011",
+        message: `Variable "{{ ${v} }}" is used but not declared in context.inputs`,
+        filePath
+      });
+    }
+  }
+  for (const v of declaredInputs) {
+    if (!usedVars.has(v)) {
+      warnings.push({
+        code: "POK012",
+        message: `Variable "${v}" is declared in context.inputs but never used`,
+        filePath
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+async function validateAssetWithIncludes(asset, filePath, frontMatterKeys) {
+  const result = validateAsset(asset, frontMatterKeys, filePath);
+  if (asset.includes && asset.includes.length > 0) {
+    try {
+      await resolveIncludes(asset, filePath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const isCircular = message.includes("Circular include");
+      result.errors.push({
+        code: isCircular ? "POK021" : "POK020",
+        message: isCircular ? `Circular include detected: ${message}` : `Include resolution failed: ${message}`,
+        filePath
+      });
+      result.valid = false;
+    }
+  }
+  return result;
+}
+function findClosestMatch(input, candidates) {
+  let best;
+  let bestDist = Infinity;
+  for (const candidate of candidates) {
+    const dist = levenshtein(input.toLowerCase(), candidate.toLowerCase());
+    if (dist < bestDist && dist <= 3) {
+      bestDist = dist;
+      best = candidate;
+    }
+  }
+  return best;
+}
+
+// src/cache.ts
+var import_node_fs = require("fs");
+var PromptCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize = 100) {
+    this.maxSize = maxSize;
+  }
+  get(filePath) {
+    const entry = this.cache.get(filePath);
+    if (!entry) return void 0;
+    try {
+      const stat = (0, import_node_fs.statSync)(filePath);
+      if (stat.mtimeMs !== entry.mtime) {
+        this.cache.delete(filePath);
+        return void 0;
+      }
+    } catch {
+      this.cache.delete(filePath);
+      return void 0;
+    }
+    return entry.value;
+  }
+  set(filePath, value) {
+    if (this.cache.size >= this.maxSize) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest) this.cache.delete(oldest);
+    }
+    try {
+      const stat = (0, import_node_fs.statSync)(filePath);
+      this.cache.set(filePath, { value, mtime: stat.mtimeMs });
+    } catch {
+    }
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+
+// src/index.ts
+var PromptOpsKit = class {
+  config;
+  promptCache;
+  constructor(config) {
+    this.config = {
+      ...config,
+      mode: config.mode ?? "auto",
+      cache: config.cache ?? true
+    };
+    this.promptCache = new PromptCache();
+  }
+  /**
+   * Load a prompt asset from compiled or source, based on mode.
+   */
+  async loadPrompt(promptPath) {
+    const mode = this.config.mode;
+    if (mode !== "source-only" && this.config.compiledDir) {
+      const compiledFile = (0, import_node_path2.resolve)(this.config.compiledDir, promptPath + ".json");
+      if ((0, import_node_fs2.existsSync)(compiledFile)) {
+        if (mode === "auto") {
+          const sourceFile = (0, import_node_path2.resolve)(this.config.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;
+            if (sourceMtime > compiledMtime) {
+              console.warn(
+                `[promptopskit] Warning: compiled artifact for "${promptPath}" is older than source .md file.
+               Run "promptopskit compile" or switch to source-only mode.`
+              );
+            }
+          }
+        }
+        const content = await (0, import_promises3.readFile)(compiledFile, "utf-8");
+        return JSON.parse(content);
+      }
+      if (mode === "compiled-only") {
+        throw new Error(
+          `Compiled artifact not found: ${compiledFile}
+Run "promptopskit compile" to generate it.`
+        );
+      }
+    }
+    if (mode !== "compiled-only") {
+      const sourceFile = (0, import_node_path2.resolve)(this.config.sourceDir, promptPath + ".md");
+      if (this.config.cache) {
+        const cached = this.promptCache.get(sourceFile);
+        if (cached) return cached;
+      }
+      if (!(0, import_node_fs2.existsSync)(sourceFile)) {
+        const paths = [sourceFile];
+        if (this.config.compiledDir) {
+          paths.unshift((0, import_node_path2.resolve)(this.config.compiledDir, promptPath + ".json"));
+        }
+        throw new Error(
+          `Prompt not found: "${promptPath}"
+Searched:
+${paths.map((p) => `  - ${p}`).join("\n")}`
+        );
+      }
+      const content = await (0, import_promises3.readFile)(sourceFile, "utf-8");
+      const { asset } = parsePrompt(content, sourceFile);
+      if (this.config.cache) {
+        this.promptCache.set(sourceFile, asset);
+      }
+      return asset;
+    }
+    throw new Error(`Prompt not found: "${promptPath}"`);
+  }
+  /**
+   * Resolve a prompt: load, resolve includes, apply overrides.
+   */
+  async resolvePrompt(promptPath, options = {}) {
+    let asset = await this.loadPrompt(promptPath);
+    const sourceFile = (0, import_node_path2.resolve)(this.config.sourceDir, promptPath + ".md");
+    if (asset.includes && asset.includes.length > 0 && (0, import_node_fs2.existsSync)(sourceFile)) {
+      asset = await resolveIncludes(asset, sourceFile);
+    }
+    asset = applyOverrides(asset, {
+      environment: options.environment,
+      tier: options.tier
+    });
+    return asset;
+  }
+  /**
+   * Render a prompt for a specific provider.
+   */
+  async renderPrompt(options) {
+    let resolved;
+    if (options.source) {
+      const { asset } = parsePrompt(options.source);
+      const overridden = applyOverrides(asset, {
+        environment: options.environment,
+        tier: options.tier
+      });
+      resolved = overridden;
+    } else if (options.path) {
+      resolved = await this.resolvePrompt(options.path, {
+        environment: options.environment,
+        tier: options.tier
+      });
+    } else {
+      throw new Error('Either "path" or "source" must be provided to renderPrompt()');
+    }
+    const adapter = getAdapter(options.provider);
+    const validation = adapter.validate(resolved);
+    if (!validation.valid) {
+      throw new Error(
+        `Provider validation failed for "${options.provider}":
+` + validation.errors.map((e) => `  - ${e}`).join("\n")
+      );
+    }
+    const request = adapter.render(resolved, {
+      variables: options.variables,
+      history: options.history,
+      toolRegistry: options.toolRegistry,
+      strict: options.strict
+    });
+    return {
+      resolved,
+      request,
+      warnings: validation.warnings
+    };
+  }
+  /**
+   * Validate a prompt file.
+   */
+  async validatePrompt(promptPath) {
+    const asset = await this.loadPrompt(promptPath);
+    return validateAsset(asset, void 0, promptPath);
+  }
+  /**
+   * Clear the internal cache.
+   */
+  clearCache() {
+    this.promptCache.clear();
+  }
+};
+function createPromptOpsKit(config) {
+  return new PromptOpsKit(config);
+}
+async function renderPrompt(options) {
+  const kit = createPromptOpsKit({
+    sourceDir: options.sourceDir ?? ".",
+    cache: false
+  });
+  return kit.renderPrompt(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PromptAssetOverridesSchema,
+  PromptAssetSchema,
+  PromptOpsKit,
+  anthropicAdapter,
+  applyOverrides,
+  createPromptOpsKit,
+  extractSections,
+  extractVariables,
+  geminiAdapter,
+  getAdapter,
+  interpolate,
+  loadPromptFile,
+  openaiAdapter,
+  openrouterAdapter,
+  parsePrompt,
+  renderPrompt,
+  resolveIncludes,
+  validateAsset,
+  validateAssetWithIncludes
+});
+//# sourceMappingURL=index.cjs.map