@promptscore/core 0.1.1

package/dist/index.js

@@ -0,0 +1,1120 @@
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { dirname, resolve, join } from 'path';
+import { fileURLToPath } from 'url';
+import { parse } from 'yaml';
+
+// src/parser/index.ts
+var ROLE_PATTERNS = [
+  /^you are\b[^.\n]*[.\n]/i,
+  /^you're\b[^.\n]*[.\n]/i,
+  /^act as\b[^.\n]*[.\n]/i,
+  /^your role is\b[^.\n]*[.\n]/i,
+  /^assume the role of\b[^.\n]*[.\n]/i,
+  /^imagine you are\b[^.\n]*[.\n]/i,
+  /^pretend to be\b[^.\n]*[.\n]/i
+];
+var TASK_KEYWORDS = [
+  /\byour task is\b/i,
+  /\byour job is\b/i,
+  /\byour goal is\b/i,
+  /\bplease\s+(?:write|explain|generate|analyze|summarize|translate|classify|extract|create|produce|list|describe)\b/i,
+  /\b(?:write|explain|generate|analyze|summarize|translate|classify|extract|create|produce|list|describe) (?:a|an|the)\b/i
+];
+var CONSTRAINT_KEYWORDS = [
+  /\b(?:must|should|should not|shouldn't|must not|mustn't|never|always|do not|don't|avoid|ensure|make sure|only)\b/i,
+  /\b(?:maximum|minimum|at most|at least|no more than|no less than|exactly)\b/i
+];
+var OUTPUT_FORMAT_KEYWORDS = [
+  /\b(?:output|respond|return|reply|answer)\s+(?:in|as|with|using)\s+(?:json|xml|yaml|markdown|html|csv|a list|a table|bullet points?|plain text|paragraphs?)\b/i,
+  /\bformat\s*:\s*(?:json|xml|yaml|markdown|html|csv|list|table)\b/i,
+  /\bin (?:json|xml|yaml|markdown|html|csv) format\b/i,
+  /\b(?:output|response|answer) format\b/i
+];
+var EXAMPLE_KEYWORDS = [
+  /\bfor example\b/i,
+  /\bexamples?:/i,
+  /\be\.g\./i,
+  /\bhere (?:is|are) (?:an? )?examples?\b/i,
+  /<example>/i,
+  /\binput\s*:[\s\S]*?output\s*:/i
+];
+var TONE_KEYWORDS = [
+  /\btone\s*:/i,
+  /\b(?:in a|use a) (?:formal|casual|friendly|professional|concise|humorous|playful|serious|polite) (?:tone|voice|style|manner)\b/i,
+  /\bbe (?:formal|casual|friendly|professional|concise|humorous|playful|serious|polite)\b/i,
+  /\bwrite in a .{1,20} (?:tone|voice|style)\b/i
+];
+var FALLBACK_KEYWORDS = [
+  /\bif (?:you (?:are )?(?:unsure|don't know|cannot|can't)|unsure|unclear|not sure|unable)\b/i,
+  /\bif you cannot\b/i,
+  /\bwhen in doubt\b/i,
+  /\bas a fallback\b/i,
+  /\bedge cases?\b/i
+];
+var CONTEXT_KEYWORDS = [
+  /^context\s*:/im,
+  /^background\s*:/im,
+  /^scenario\s*:/im,
+  /^given\s*:/im,
+  /<context>/i
+];
+var XML_TAG_REGEX = /<([a-z][a-z0-9_-]*)\b[^>]*>[\s\S]*?<\/\1>/i;
+var MARKDOWN_HEADER_REGEX = /^#{1,6}\s+\S/m;
+var NUMBERED_SECTION_REGEX = /^\s*(?:\d+[.)]\s+|-\s+|\*\s+)/m;
+function countWords(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return 0;
+  return trimmed.split(/\s+/).length;
+}
+function detectLanguage(text) {
+  const sample = text.toLowerCase().slice(0, 2e3);
+  const englishMarkers = /\b(?:the|and|you|your|that|this|with|for|are|not)\b/g;
+  const matches = sample.match(englishMarkers);
+  if (matches && matches.length >= 3) return "en";
+  return "unknown";
+}
+function extractFirstMatch(text, patterns) {
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (match) {
+      return match[0].trim();
+    }
+  }
+  return void 0;
+}
+function extractRole(text) {
+  const firstLines = text.split(/\n/).slice(0, 3).join("\n");
+  for (const pattern of ROLE_PATTERNS) {
+    const match = firstLines.match(pattern);
+    if (match) return match[0].trim();
+  }
+  const xmlMatch = text.match(/<(?:role|persona)>([\s\S]*?)<\/(?:role|persona)>/i);
+  if (xmlMatch && xmlMatch[1]) return xmlMatch[1].trim();
+  return void 0;
+}
+function extractTask(text, role) {
+  const xmlMatch = text.match(
+    /<(?:task|instructions?|goal)>([\s\S]*?)<\/(?:task|instructions?|goal)>/i
+  );
+  if (xmlMatch && xmlMatch[1]) return xmlMatch[1].trim();
+  const withoutRole = role ? text.replace(role, "") : text;
+  const found = extractFirstMatch(withoutRole, TASK_KEYWORDS);
+  if (found) {
+    const idx = withoutRole.toLowerCase().indexOf(found.toLowerCase());
+    if (idx >= 0) {
+      const rest = withoutRole.slice(idx);
+      const end = rest.search(/[.!?\n]/);
+      return end > 0 ? rest.slice(0, end + 1).trim() : rest.slice(0, 200).trim();
+    }
+  }
+  return void 0;
+}
+function extractContext(text) {
+  const xmlMatch = text.match(/<context>([\s\S]*?)<\/context>/i);
+  if (xmlMatch && xmlMatch[1]) return xmlMatch[1].trim();
+  for (const pattern of CONTEXT_KEYWORDS) {
+    const match = text.match(pattern);
+    if (match && match.index !== void 0) {
+      const rest = text.slice(match.index);
+      const end = rest.search(/\n\n/);
+      return end > 0 ? rest.slice(0, end).trim() : rest.slice(0, 300).trim();
+    }
+  }
+  return void 0;
+}
+function extractConstraints(text) {
+  const constraints = [];
+  const xmlMatch = text.match(/<constraints?>([\s\S]*?)<\/constraints?>/i);
+  if (xmlMatch && xmlMatch[1]) {
+    xmlMatch[1].split(/\n/).map((line) => line.replace(/^[\s\-*\d.)]+/, "").trim()).filter(Boolean).forEach((line) => constraints.push(line));
+  }
+  const lines = text.split(/\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    for (const pattern of CONSTRAINT_KEYWORDS) {
+      if (pattern.test(trimmed) && trimmed.length < 300) {
+        constraints.push(trimmed);
+        break;
+      }
+    }
+  }
+  return Array.from(new Set(constraints));
+}
+function extractExamples(text) {
+  const examples = [];
+  const xmlRegex = /<example>([\s\S]*?)<\/example>/gi;
+  let xmlMatch;
+  while ((xmlMatch = xmlRegex.exec(text)) !== null) {
+    const body = xmlMatch[1]?.trim() ?? "";
+    const inputMatch = body.match(/input\s*:\s*([\s\S]*?)(?=output\s*:|$)/i);
+    const outputMatch = body.match(/output\s*:\s*([\s\S]*)/i);
+    examples.push({
+      raw: body,
+      input: inputMatch?.[1]?.trim(),
+      output: outputMatch?.[1]?.trim()
+    });
+  }
+  if (examples.length === 0) {
+    const ioRegex = /input\s*:\s*([\s\S]*?)\n\s*output\s*:\s*([\s\S]*?)(?=\n\s*input\s*:|\n\n|$)/gi;
+    let ioMatch;
+    while ((ioMatch = ioRegex.exec(text)) !== null) {
+      examples.push({
+        raw: ioMatch[0].trim(),
+        input: ioMatch[1]?.trim(),
+        output: ioMatch[2]?.trim()
+      });
+    }
+  }
+  if (examples.length === 0) {
+    for (const pattern of EXAMPLE_KEYWORDS) {
+      const match = text.match(pattern);
+      if (match && match.index !== void 0) {
+        const snippet = text.slice(match.index, match.index + 300);
+        examples.push({ raw: snippet.trim() });
+        break;
+      }
+    }
+  }
+  return examples;
+}
+function extractOutputFormat(text) {
+  const xmlMatch = text.match(
+    /<(?:output|format|output_format)>([\s\S]*?)<\/(?:output|format|output_format)>/i
+  );
+  if (xmlMatch && xmlMatch[1]) return xmlMatch[1].trim();
+  return extractFirstMatch(text, OUTPUT_FORMAT_KEYWORDS);
+}
+function extractTone(text) {
+  return extractFirstMatch(text, TONE_KEYWORDS);
+}
+function extractFallback(text) {
+  return extractFirstMatch(text, FALLBACK_KEYWORDS);
+}
+function parsePrompt(raw) {
+  const text = raw;
+  const role = extractRole(text);
+  const task = extractTask(text, role);
+  const context = extractContext(text);
+  const constraints = extractConstraints(text);
+  const examples = extractExamples(text);
+  const outputFormat = extractOutputFormat(text);
+  const tone = extractTone(text);
+  const fallback = extractFallback(text);
+  const components = {
+    role,
+    task,
+    context,
+    constraints: constraints.length > 0 ? constraints : void 0,
+    examples: examples.length > 0 ? examples : void 0,
+    outputFormat,
+    tone,
+    fallback
+  };
+  const hasXmlTags = XML_TAG_REGEX.test(text);
+  const hasMarkdownHeaders = MARKDOWN_HEADER_REGEX.test(text);
+  const hasNumberedSections = NUMBERED_SECTION_REGEX.test(text);
+  const metadata = {
+    wordCount: countWords(text),
+    charCount: text.length,
+    lineCount: text.split(/\n/).length,
+    language: detectLanguage(text),
+    hasStructuredFormat: hasXmlTags || hasMarkdownHeaders || hasNumberedSections,
+    hasXmlTags,
+    hasMarkdownHeaders,
+    hasNumberedSections
+  };
+  return {
+    raw: text,
+    components,
+    metadata
+  };
+}
+
+// src/rules/deterministic/min-length.ts
+var MIN_WORDS = 20;
+var minLengthRule = {
+  id: "min-length",
+  name: "Minimum length",
+  description: "Prompts shorter than 20 words rarely give a model enough to work with.",
+  category: "specificity",
+  defaultSeverity: "warning",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const wc = ast.metadata.wordCount;
+    const passed = wc >= MIN_WORDS;
+    const score = passed ? 100 : Math.round(wc / MIN_WORDS * 100);
+    return {
+      ruleId: "min-length",
+      passed,
+      score,
+      message: passed ? `Prompt length (${wc} words) is sufficient.` : `Prompt is very short (${wc} words). Models need enough context to respond well.`,
+      suggestion: passed ? void 0 : "Add more detail about what you want, why, and how the output should look.",
+      severity: "warning",
+      category: "specificity",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/max-length.ts
+var SOFT_MAX = 1500;
+var HARD_MAX = 3e3;
+var maxLengthRule = {
+  id: "max-length",
+  name: "Maximum length",
+  description: "Excessively long prompts often contain redundancy and dilute the model\u2019s focus.",
+  category: "structure",
+  defaultSeverity: "info",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const wc = ast.metadata.wordCount;
+    let score = 100;
+    if (wc > SOFT_MAX) {
+      const over = Math.min(wc - SOFT_MAX, HARD_MAX - SOFT_MAX);
+      score = Math.max(0, 100 - Math.round(over / (HARD_MAX - SOFT_MAX) * 100));
+    }
+    const passed = wc <= SOFT_MAX;
+    return {
+      ruleId: "max-length",
+      passed,
+      score,
+      message: passed ? `Prompt length (${wc} words) is within a comfortable range.` : `Prompt is long (${wc} words). Consider trimming redundancy or splitting into smaller prompts.`,
+      suggestion: passed ? void 0 : "Look for repeated instructions, bundled unrelated tasks, or sections that can be summarized.",
+      severity: "info",
+      category: "structure",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/no-output-format.ts
+var noOutputFormatRule = {
+  id: "no-output-format",
+  name: "Output format specified",
+  description: "The prompt should tell the model exactly how to format its answer.",
+  category: "specificity",
+  defaultSeverity: "warning",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const passed = Boolean(ast.components.outputFormat);
+    return {
+      ruleId: "no-output-format",
+      passed,
+      score: passed ? 100 : 0,
+      message: passed ? "An output format is specified." : "No output format is specified. The model will guess what you want.",
+      suggestion: passed ? void 0 : "State the exact format: JSON schema, bullet list, markdown table, single sentence, etc.",
+      severity: "warning",
+      category: "specificity",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/no-examples.ts
+var noExamplesRule = {
+  id: "no-examples",
+  name: "Examples provided",
+  description: "Few-shot examples dramatically improve output quality and consistency.",
+  category: "best-practice",
+  defaultSeverity: "warning",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const count = ast.components.examples?.length ?? 0;
+    const passed = count > 0;
+    return {
+      ruleId: "no-examples",
+      passed,
+      score: passed ? 100 : 0,
+      message: passed ? `Prompt includes ${count} example${count === 1 ? "" : "s"}.` : "No examples provided. Few-shot examples usually improve output quality.",
+      suggestion: passed ? void 0 : "Add 1\u20133 concrete examples showing the input and the expected output.",
+      severity: "warning",
+      category: "best-practice",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/no-role.ts
+var noRoleRule = {
+  id: "no-role",
+  name: "Role or persona assigned",
+  description: "Assigning a role focuses the model and sets expectations for expertise and tone.",
+  category: "best-practice",
+  defaultSeverity: "info",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const passed = Boolean(ast.components.role);
+    return {
+      ruleId: "no-role",
+      passed,
+      score: passed ? 100 : 0,
+      message: passed ? "A role or persona is assigned." : "No role assigned. Consider giving the model a persona aligned with the task.",
+      suggestion: passed ? void 0 : 'Start with something like "You are a senior <X> who specializes in <Y>."',
+      severity: "info",
+      category: "best-practice",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/no-context.ts
+var noContextRule = {
+  id: "no-context",
+  name: "Background context provided",
+  description: "Context helps the model understand the situation, audience, and constraints.",
+  category: "specificity",
+  defaultSeverity: "info",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const passed = Boolean(ast.components.context) || ast.metadata.wordCount >= 80;
+    return {
+      ruleId: "no-context",
+      passed,
+      score: passed ? 100 : 40,
+      message: passed ? "Prompt provides context or is detailed enough to imply it." : "No background context detected. The model may miss important situational cues.",
+      suggestion: passed ? void 0 : "Explain the situation: who the user is, why they\u2019re asking, and what the stakes are.",
+      severity: "info",
+      category: "specificity",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/ambiguous-negation.ts
+var NEGATION_PATTERN = /\b(?:don't|do not|never|avoid|shouldn't|should not|must not|mustn't)\b/gi;
+var ambiguousNegationRule = {
+  id: "ambiguous-negation",
+  name: "Ambiguous negative instructions",
+  description: `Negative instructions ("don't do X") are less effective than positive ones ("do Y").`,
+  category: "clarity",
+  defaultSeverity: "info",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const matches = ast.raw.match(NEGATION_PATTERN) ?? [];
+    const wc = ast.metadata.wordCount || 1;
+    const ratio = matches.length / wc;
+    const passed = matches.length < 3 || ratio < 0.05;
+    const score = passed ? 100 : Math.max(20, 100 - matches.length * 10);
+    return {
+      ruleId: "ambiguous-negation",
+      passed,
+      score,
+      message: passed ? `Negative instructions are used sparingly (${matches.length} found).` : `Heavy use of negative instructions (${matches.length} found). Models follow positive instructions more reliably.`,
+      suggestion: passed ? void 0 : `Rewrite "don't do X" as "do Y instead". Tell the model what the desired behavior is.`,
+      severity: "info",
+      category: "clarity",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/no-constraints.ts
+var noConstraintsRule = {
+  id: "no-constraints",
+  name: "Constraints defined",
+  description: "Explicit constraints keep the model on track and prevent scope drift.",
+  category: "specificity",
+  defaultSeverity: "info",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const count = ast.components.constraints?.length ?? 0;
+    const passed = count > 0;
+    return {
+      ruleId: "no-constraints",
+      passed,
+      score: passed ? 100 : 0,
+      message: passed ? `Prompt defines ${count} constraint${count === 1 ? "" : "s"}.` : "No constraints detected. The model has no guardrails on length, scope, or style.",
+      suggestion: passed ? void 0 : "Add constraints like length limits, scope boundaries, or things the answer must include.",
+      severity: "info",
+      category: "specificity",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/all-caps-abuse.ts
+var CAPS_WORD_PATTERN = /\b[A-Z]{4,}\b/g;
+var allCapsAbuseRule = {
+  id: "all-caps-abuse",
+  name: "All-caps abuse",
+  description: "Excessive ALL CAPS is noisy and rarely the clearest way to emphasize something.",
+  category: "clarity",
+  defaultSeverity: "info",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const caps = ast.raw.match(CAPS_WORD_PATTERN) ?? [];
+    const wc = ast.metadata.wordCount || 1;
+    const ratio = caps.length / wc;
+    const passed = ratio < 0.05 && caps.length < 8;
+    const score = passed ? 100 : Math.max(30, 100 - Math.round(ratio * 1e3));
+    return {
+      ruleId: "all-caps-abuse",
+      passed,
+      score,
+      message: passed ? "All-caps usage is within reasonable limits." : `Excessive ALL CAPS (${caps.length} words). This rarely improves comprehension.`,
+      suggestion: passed ? void 0 : "Use bold (**word**), quotes, or XML tags for emphasis instead of ALL CAPS.",
+      severity: "info",
+      category: "clarity",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/vague-instruction.ts
+var VAGUE_WORDS = [
+  "good",
+  "nice",
+  "proper",
+  "appropriate",
+  "correct",
+  "better",
+  "high quality",
+  "high-quality",
+  "reasonable",
+  "decent",
+  "suitable"
+];
+function buildVaguePattern() {
+  const escaped = VAGUE_WORDS.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(`\\b(?:${escaped.join("|")})\\b`, "gi");
+}
+var VAGUE_PATTERN = buildVaguePattern();
+var vagueInstructionRule = {
+  id: "vague-instruction",
+  name: "Vague instructions",
+  description: 'Vague words like "good", "proper", or "appropriate" do not give the model a concrete target.',
+  category: "clarity",
+  defaultSeverity: "warning",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const matches = ast.raw.match(VAGUE_PATTERN) ?? [];
+    const unique = Array.from(new Set(matches.map((m) => m.toLowerCase())));
+    const passed = matches.length === 0;
+    const score = passed ? 100 : Math.max(25, 100 - matches.length * 15);
+    return {
+      ruleId: "vague-instruction",
+      passed,
+      score,
+      message: passed ? "No vague qualifiers detected." : `Vague qualifiers used: ${unique.join(", ")}.`,
+      suggestion: passed ? void 0 : 'Replace vague words with measurable criteria. "Good" \u2192 "concise (\u2264 3 sentences) and citing sources".',
+      severity: "warning",
+      category: "clarity",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/missing-task.ts
+var missingTaskRule = {
+  id: "missing-task",
+  name: "Clear task or instruction",
+  description: "Every prompt should have an unambiguous instruction telling the model what to do.",
+  category: "clarity",
+  defaultSeverity: "error",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const passed = Boolean(ast.components.task);
+    return {
+      ruleId: "missing-task",
+      passed,
+      score: passed ? 100 : 0,
+      message: passed ? "A clear task is present." : "No explicit task detected. The model may not know what you want it to do.",
+      suggestion: passed ? void 0 : 'State the task explicitly: "Your task is to..." or "Please <verb> <object>".',
+      severity: "error",
+      category: "clarity",
+      weight: 1.5
+    };
+  }
+};
+
+// src/rules/deterministic/no-structured-format.ts
+var LONG_PROMPT_THRESHOLD = 100;
+var noStructuredFormatRule = {
+  id: "no-structured-format",
+  name: "Structured formatting",
+  description: "Long prompts are easier for a model to follow when broken into sections (XML tags, headers, lists).",
+  category: "structure",
+  defaultSeverity: "warning",
+  type: "deterministic",
+  check: ({ ast }) => {
+    const wc = ast.metadata.wordCount;
+    const structured = ast.metadata.hasStructuredFormat;
+    const passed = wc < LONG_PROMPT_THRESHOLD || structured;
+    const score = passed ? 100 : 40;
+    return {
+      ruleId: "no-structured-format",
+      passed,
+      score,
+      message: passed ? structured ? "Prompt uses structured formatting." : "Prompt is short enough to not need structural formatting." : `Long prompt (${wc} words) without structural markers like XML tags, headers, or numbered sections.`,
+      suggestion: passed ? void 0 : "Split the prompt into labeled sections: <instructions>, <context>, <examples>, <output_format>.",
+      severity: "warning",
+      category: "structure",
+      weight: 1
+    };
+  }
+};
+
+// src/rules/deterministic/index.ts
+var deterministicRules = [
+  minLengthRule,
+  maxLengthRule,
+  noOutputFormatRule,
+  noExamplesRule,
+  noRoleRule,
+  noContextRule,
+  ambiguousNegationRule,
+  noConstraintsRule,
+  allCapsAbuseRule,
+  vagueInstructionRule,
+  missingTaskRule,
+  noStructuredFormatRule
+];
+
+// src/rules/registry.ts
+var RuleRegistry = class {
+  rules = /* @__PURE__ */ new Map();
+  constructor(initialRules = []) {
+    for (const rule of initialRules) {
+      this.register(rule);
+    }
+  }
+  register(rule) {
+    if (this.rules.has(rule.id)) {
+      throw new Error(`Rule with id "${rule.id}" is already registered`);
+    }
+    this.rules.set(rule.id, rule);
+  }
+  get(id) {
+    return this.rules.get(id);
+  }
+  has(id) {
+    return this.rules.has(id);
+  }
+  all() {
+    return Array.from(this.rules.values());
+  }
+  byType(type) {
+    return this.all().filter((rule) => rule.type === type);
+  }
+  byIds(ids) {
+    const out = [];
+    for (const id of ids) {
+      const rule = this.rules.get(id);
+      if (rule) out.push(rule);
+    }
+    return out;
+  }
+};
+function createDefaultRegistry() {
+  return new RuleRegistry(deterministicRules);
+}
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = dirname(__filename$1);
+function findProfilesDir(startDir) {
+  let current = startDir;
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(current, "profiles");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+}
+function normalize(raw, name) {
+  return {
+    name: raw.name ?? name,
+    displayName: raw.display_name ?? raw.name ?? name,
+    version: raw.version,
+    base: raw.base,
+    rules: raw.rules ?? {},
+    bestPractices: raw.best_practices ?? []
+  };
+}
+function mergeOverrides(base, override) {
+  return {
+    severity: override?.severity ?? base?.severity,
+    weight: override?.weight ?? base?.weight,
+    suggestion: override?.suggestion ?? base?.suggestion,
+    reference: override?.reference ?? base?.reference,
+    enabled: override?.enabled ?? base?.enabled
+  };
+}
+function mergeProfiles(base, child) {
+  const ruleIds = /* @__PURE__ */ new Set([...Object.keys(base.rules), ...Object.keys(child.rules)]);
+  const merged = {};
+  for (const id of ruleIds) {
+    merged[id] = mergeOverrides(base.rules[id], child.rules[id]);
+  }
+  return {
+    name: child.name,
+    displayName: child.displayName,
+    version: child.version ?? base.version,
+    base: child.base,
+    rules: merged,
+    bestPractices: [...base.bestPractices, ...child.bestPractices]
+  };
+}
+var ProfileLoader = class {
+  profilesDir;
+  cache = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    const found = options.profilesDir ?? findProfilesDir(__dirname$1) ?? findProfilesDir(process.cwd());
+    if (!found) {
+      throw new Error("Could not locate a `profiles/` directory. Pass `profilesDir` explicitly.");
+    }
+    this.profilesDir = resolve(found);
+  }
+  get directory() {
+    return this.profilesDir;
+  }
+  async load(name) {
+    if (this.cache.has(name)) {
+      return this.cache.get(name);
+    }
+    const filePath = join(this.profilesDir, `${name}.yaml`);
+    if (!existsSync(filePath)) {
+      throw new Error(`Profile "${name}" not found at ${filePath}`);
+    }
+    const content = await readFile(filePath, "utf8");
+    const raw = parse(content) ?? {};
+    let profile = normalize(raw, name);
+    if (profile.base) {
+      const base = await this.load(profile.base);
+      profile = mergeProfiles(base, profile);
+    }
+    this.cache.set(name, profile);
+    return profile;
+  }
+  async list() {
+    const { readdir } = await import('fs/promises');
+    const files = await readdir(this.profilesDir);
+    return files.filter((f) => f.endsWith(".yaml") && !f.startsWith("_")).map((f) => f.replace(/\.yaml$/, ""));
+  }
+};
+
+// src/scorer/index.ts
+function isRuleEnabled(rule, profile) {
+  const override = profile.rules[rule.id];
+  if (override?.enabled === false) return false;
+  return true;
+}
+function applyOverride(result, profile) {
+  const override = profile.rules[result.ruleId];
+  if (!override) return result;
+  return {
+    ...result,
+    severity: override.severity ?? result.severity,
+    weight: override.weight ?? result.weight,
+    suggestion: override.suggestion ?? result.suggestion,
+    reference: override.reference ?? result.reference
+  };
+}
+async function runRules(options) {
+  const { rules, profile, ast, only, includeLlm } = options;
+  const results = [];
+  for (const rule of rules) {
+    if (only && !only.includes(rule.id)) continue;
+    if (!isRuleEnabled(rule, profile)) continue;
+    if (rule.type === "llm" && !includeLlm) continue;
+    const base = await rule.check({ ast, profile });
+    results.push(applyOverride(base, profile));
+  }
+  return results;
+}
+function groupByCategory(results) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const existing = grouped.get(result.category) ?? [];
+    existing.push(result);
+    grouped.set(result.category, existing);
+  }
+  return grouped;
+}
+function weightedAverage(values, weights) {
+  const totalWeight = weights.reduce((a, b) => a + b, 0);
+  if (totalWeight === 0) return 0;
+  const sum = values.reduce((acc, v, i) => acc + v * (weights[i] ?? 1), 0);
+  return sum / totalWeight;
+}
+function buildSummary(overall, results) {
+  const failed = results.filter((r) => !r.passed);
+  if (failed.length === 0) return `Score ${Math.round(overall)}/100 \u2014 strong prompt.`;
+  const errors = failed.filter((r) => r.severity === "error").length;
+  const warnings = failed.filter((r) => r.severity === "warning").length;
+  const pieces = [];
+  if (errors) pieces.push(`${errors} error${errors === 1 ? "" : "s"}`);
+  if (warnings) pieces.push(`${warnings} warning${warnings === 1 ? "" : "s"}`);
+  const extras = failed.length - errors - warnings;
+  if (extras > 0) pieces.push(`${extras} info`);
+  return `Score ${Math.round(overall)}/100 \u2014 ${pieces.join(", ")}.`;
+}
+function buildSuggestions(results) {
+  const severityRank = {
+    error: 3,
+    warning: 2,
+    info: 1
+  };
+  return results.filter((r) => !r.passed && r.suggestion).map((r) => ({
+    ruleId: r.ruleId,
+    severity: r.severity,
+    message: r.message,
+    suggestion: r.suggestion,
+    reference: r.reference,
+    impact: (100 - r.score) * r.weight * severityRank[r.severity]
+  })).sort((a, b) => b.impact - a.impact);
+}
+function buildReport(results, profile) {
+  const grouped = groupByCategory(results);
+  const categories = [];
+  for (const [category, rs] of grouped) {
+    const score = weightedAverage(
+      rs.map((r) => r.score),
+      rs.map((r) => r.weight)
+    );
+    categories.push({ category, score, rules: rs });
+  }
+  const overall = weightedAverage(
+    categories.map((c2) => c2.score),
+    categories.map((c2) => c2.rules.reduce((a, r) => a + r.weight, 0))
+  );
+  return {
+    overall,
+    categories,
+    summary: buildSummary(overall, results),
+    suggestions: buildSuggestions(results),
+    results,
+    profileName: profile.name
+  };
+}
+
+// src/profiles/builtin.ts
+function mergeOverrides2(base, override) {
+  return {
+    severity: override?.severity ?? base?.severity,
+    weight: override?.weight ?? base?.weight,
+    suggestion: override?.suggestion ?? base?.suggestion,
+    reference: override?.reference ?? base?.reference,
+    enabled: override?.enabled ?? base?.enabled
+  };
+}
+function mergeProfiles2(base, child) {
+  const ruleIds = /* @__PURE__ */ new Set([...Object.keys(base.rules), ...Object.keys(child.rules)]);
+  const rules = {};
+  for (const ruleId of ruleIds) {
+    rules[ruleId] = mergeOverrides2(base.rules[ruleId], child.rules[ruleId]);
+  }
+  return {
+    name: child.name,
+    displayName: child.displayName,
+    version: child.version ?? base.version,
+    base: child.base,
+    rules,
+    bestPractices: [...base.bestPractices, ...child.bestPractices]
+  };
+}
+var baseProfile = {
+  name: "_base",
+  displayName: "Model-agnostic baseline",
+  version: "2026-04",
+  base: void 0,
+  rules: {
+    "min-length": {
+      severity: "warning",
+      weight: 1
+    },
+    "max-length": {
+      severity: "info",
+      weight: 0.8
+    },
+    "no-output-format": {
+      severity: "warning",
+      weight: 1.2,
+      suggestion: "Tell the model the exact format you want (JSON schema, bullet list, single sentence, etc.)."
+    },
+    "no-examples": {
+      severity: "warning",
+      weight: 1,
+      suggestion: "Add 1\u20133 concrete examples showing the input and the expected output."
+    },
+    "no-role": {
+      severity: "info",
+      weight: 0.8
+    },
+    "no-context": {
+      severity: "info",
+      weight: 0.9
+    },
+    "ambiguous-negation": {
+      severity: "info",
+      weight: 0.8
+    },
+    "no-constraints": {
+      severity: "info",
+      weight: 0.9
+    },
+    "all-caps-abuse": {
+      severity: "info",
+      weight: 0.6
+    },
+    "vague-instruction": {
+      severity: "warning",
+      weight: 1.1
+    },
+    "missing-task": {
+      severity: "error",
+      weight: 2
+    },
+    "no-structured-format": {
+      severity: "warning",
+      weight: 1
+    }
+  },
+  bestPractices: [
+    "Be explicit about the task \u2014 one clear instruction beats several vague ones.",
+    "Include at least one concrete example when the output format matters.",
+    "Prefer positive instructions ('do Y') over negative ones ('don't do X').",
+    "Specify the exact output format the model should return.",
+    "Break long prompts into labeled sections."
+  ]
+};
+var claudeOverrides = {
+  name: "claude",
+  displayName: "Anthropic Claude",
+  version: "2026-04",
+  base: "_base",
+  rules: {
+    "no-output-format": {
+      severity: "warning",
+      weight: 1.2,
+      suggestion: "Claude responds well to XML-tagged output format instructions like <output_format>.",
+      reference: "https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering"
+    },
+    "no-examples": {
+      severity: "warning",
+      weight: 1.5,
+      suggestion: "Claude benefits significantly from 2\u20133 few-shot examples inside <example> tags.",
+      reference: "https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/multishot-prompting"
+    },
+    "no-structured-format": {
+      severity: "warning",
+      weight: 1.3,
+      suggestion: "Claude handles XML tags particularly well for separating sections.",
+      reference: "https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/use-xml-tags"
+    },
+    "ambiguous-negation": {
+      severity: "warning",
+      weight: 1.1,
+      suggestion: "Claude follows positive framings more reliably than negations."
+    }
+  },
+  bestPractices: [
+    "Use XML tags to separate sections: <instructions>, <context>, <example>, <output_format>.",
+    "Put the most important instructions at both the beginning and the end of the prompt.",
+    "Use positive instructions ('do X') rather than negative ('don't do Y').",
+    "Provide 2\u20133 examples of the expected output format.",
+    "For long prompts, wrap each section in an XML tag so Claude can refer back to it."
+  ]
+};
+var gptOverrides = {
+  name: "gpt",
+  displayName: "OpenAI GPT",
+  version: "2026-04",
+  base: "_base",
+  rules: {
+    "no-output-format": {
+      severity: "warning",
+      weight: 1.3,
+      suggestion: "GPT responds well to explicit format instructions \u2014 mention JSON schema or a numbered list if relevant.",
+      reference: "https://platform.openai.com/docs/guides/prompt-engineering"
+    },
+    "no-examples": {
+      severity: "warning",
+      weight: 1.3,
+      suggestion: "Use a system + user pattern with few-shot examples to anchor GPT\u2019s behavior."
+    },
+    "no-structured-format": {
+      severity: "warning",
+      weight: 1.1,
+      suggestion: "Markdown headers and numbered sections work well for GPT."
+    },
+    "no-role": {
+      severity: "info",
+      weight: 1,
+      suggestion: "GPT responds well when given an explicit persona via a system message."
+    }
+  },
+  bestPractices: [
+    "Use a system message to set the persona and global instructions.",
+    "Structure long prompts with markdown headers (## Context, ## Task, ## Output).",
+    "For structured output, prefer JSON schema or response_format: json_object.",
+    "Include a handful of few-shot examples if format matters.",
+    "Be explicit about what the model should not do, but always pair with what it should do."
+  ]
+};
+var builtinProfiles = {
+  _base: baseProfile,
+  claude: mergeProfiles2(baseProfile, claudeOverrides),
+  gpt: mergeProfiles2(baseProfile, gptOverrides)
+};
+function getBuiltinProfile(name) {
+  return structuredClone(builtinProfiles[name]);
+}
+
+// src/reporter/index.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+function c(color, text, enabled) {
+  if (!enabled) return text;
+  return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+function severityColor(sev) {
+  if (sev === "error") return "red";
+  if (sev === "warning") return "yellow";
+  return "blue";
+}
+function severityLabel(sev) {
+  if (sev === "error") return "error";
+  if (sev === "warning") return "warn ";
+  return "info ";
+}
+function scoreColor(score) {
+  if (score >= 80) return "green";
+  if (score >= 50) return "yellow";
+  return "red";
+}
+function formatText(report, options = {}) {
+  const color = options.color ?? true;
+  const out = [];
+  const overallRounded = Math.round(report.overall);
+  const bar = buildBar(overallRounded, 30);
+  out.push(c("bold", `PromptScore \u2014 profile: ${report.profileName}`, color));
+  out.push("");
+  out.push(
+    `${c("bold", "Overall", color)}  ${c(scoreColor(overallRounded), `${overallRounded}/100`, color)}  ${bar}`
+  );
+  out.push(c("dim", report.summary, color));
+  out.push("");
+  out.push(c("bold", "Categories", color));
+  for (const category of report.categories) {
+    const s = Math.round(category.score);
+    out.push(
+      `  ${category.category.padEnd(16)} ${c(scoreColor(s), `${String(s).padStart(3)}/100`, color)} ${c("dim", `(${category.rules.length} rules)`, color)}`
+    );
+  }
+  out.push("");
+  const failed = report.results.filter((r) => !r.passed);
+  if (failed.length > 0) {
+    out.push(c("bold", "Findings", color));
+    for (const result of failed) {
+      const label = c(severityColor(result.severity), severityLabel(result.severity), color);
+      out.push(`  ${label}  ${c("bold", result.ruleId, color)}  ${result.message}`);
+      if (result.suggestion) {
+        out.push(c("dim", `         \u2192 ${result.suggestion}`, color));
+      }
+      if (result.reference) {
+        out.push(c("dim", `         see: ${result.reference}`, color));
+      }
+    }
+    out.push("");
+  }
+  const passed = report.results.filter((r) => r.passed);
+  if (passed.length > 0) {
+    out.push(c("dim", `${passed.length} rule${passed.length === 1 ? "" : "s"} passed.`, color));
+  }
+  return out.join("\n");
+}
+function buildBar(score, width) {
+  const filled = Math.round(score / 100 * width);
+  const empty = width - filled;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}]`;
+}
+function formatJson(report, pretty = true) {
+  return JSON.stringify(report, null, pretty ? 2 : 0);
+}
+function formatMarkdown(report) {
+  const out = [];
+  out.push(`# PromptScore \u2014 ${report.profileName}`);
+  out.push("");
+  out.push(`**Overall:** ${Math.round(report.overall)}/100`);
+  out.push("");
+  out.push(`> ${report.summary}`);
+  out.push("");
+  out.push("## Categories");
+  out.push("");
+  out.push("| Category | Score | Rules |");
+  out.push("| --- | --- | --- |");
+  for (const category of report.categories) {
+    out.push(
+      `| ${category.category} | ${Math.round(category.score)}/100 | ${category.rules.length} |`
+    );
+  }
+  out.push("");
+  const failed = report.results.filter((r) => !r.passed);
+  if (failed.length > 0) {
+    out.push("## Findings");
+    out.push("");
+    for (const result of failed) {
+      out.push(`### \`${result.ruleId}\` \u2014 ${result.severity}`);
+      out.push("");
+      out.push(result.message);
+      if (result.suggestion) {
+        out.push("");
+        out.push(`**Suggestion:** ${result.suggestion}`);
+      }
+      if (result.reference) {
+        out.push("");
+        out.push(`**Reference:** ${result.reference}`);
+      }
+      out.push("");
+    }
+  }
+  return out.join("\n");
+}
+function format(report, fmt, options = {}) {
+  if (fmt === "json") return formatJson(report);
+  if (fmt === "markdown") return formatMarkdown(report);
+  return formatText(report, options);
+}
+
+// src/index.ts
+async function analyze(prompt, options = {}) {
+  const ast = parsePrompt(prompt);
+  const registry = options.registry ?? createDefaultRegistry();
+  if (options.extraRules) {
+    for (const rule of options.extraRules) {
+      if (!registry.has(rule.id)) registry.register(rule);
+    }
+  }
+  let profile;
+  if (options.profile) {
+    profile = options.profile;
+  } else {
+    const loader = new ProfileLoader(options.profileOptions ?? {});
+    profile = await loader.load(options.model ?? "_base");
+  }
+  const results = await runRules({
+    rules: registry.all(),
+    profile,
+    ast,
+    only: options.only,
+    includeLlm: options.includeLlm
+  });
+  return buildReport(results, profile);
+}
+
+export { ProfileLoader, RuleRegistry, analyze, buildReport, builtinProfiles, createDefaultRegistry, deterministicRules, format, formatJson, formatMarkdown, formatText, getBuiltinProfile, parsePrompt, runRules };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map