@prompt-lint/rules 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PromptLint Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# `@prompt-lint/rules`
+
+Built-in lint rules for PromptLint V1.
+
+This package ships the complete V1 catalog of rules declared in
+`RULES_MANIFEST`. Each rule lives in its own file under `src/`,
+grouped into one subdirectory per category:
+
+- `structure/` – `missing-model`, `missing-description`,
+  `unused-variable`, `undefined-variable`.
+- `cost/` – `high-token-estimate`.
+- `security/` – `pii-pattern`, `instruction-override-pattern`.
+- `quality/` – `missing-output-schema`, `vague-quantifier-language`.
+- `convention/` – `filename-naming`.
+
+A shared `helpers/` directory hosts the pure utility layer used by the
+rules: regex construction, variable inspection, token estimation,
+filename normalization, PII / instruction-override vocabulary,
+structured-data phrasing, and vague-quantifier detection.
+
+## Public API
+
+```ts
+import {
+  RULES_MANIFEST,
+  definedRuleIds,
+  findManifestEntry,
+  getImplementedRules,
+  // Individual rule definitions are also re-exported by id-prefixed name.
+  structureMissingModel,
+  costHighTokenEstimate,
+} from "@prompt-lint/rules"
+
+// Returns every implemented rule in the order defined by RULES_MANIFEST.
+const rules = getImplementedRules()
+
+// Look up manifest metadata by id.
+const entry = findManifestEntry("quality/missing-output-schema")
+
+// Hand the rules to the engine.
+const result = await runEngine({ rules, files })
+```
+
+`RULES_MANIFEST` is the immutable source of truth: the catalog order is
+locked and the `assertManifestOrder` runtime guard in `src/index.ts`
+fails noisily if `getImplementedRules()` ever drifts apart from it.
+
+## Writing a new rule
+
+1. Place the implementation in the appropriate category subdirectory.
+2. Use `defineRule` from `@prompt-lint/rule-engine`.
+3. Consume the `RuleContext` (`file`, `options`, `report`).
+4. Emit deterministic findings; the engine handles dedup and ordering.
+5. Declare options via the `options:` array when the rule accepts
+   configuration.
+6. Re-export the rule from `src/index.ts` (both as a named export and as
+   part of `getImplementedRules()`).
+7. Cover the rule with unit tests colocated in the same directory.
+8. Update `RULES_MANIFEST` in `src/generated/manifest.ts` and add a
+   matching phase entry to `PROJECT-AUDIT.md`.
+
+## Tests
+
+```bash
+pnpm --filter @prompt-lint/rules test:run
+```
+
+Every rule runs against the same harness — `src/test-helpers.ts` —
+which auto-extracts `{{ variable }}` references from the body. Tests
+cover valid prompts, invalid prompts, empty bodies, unicode content,
+multiple findings, filename edge cases, configurable options, and
+malformed markdown where relevant.

package/dist/convention/filename-naming.d.ts

@@ -0,0 +1,16 @@
+import type { RuleDefinition } from "@prompt-lint/types";
+/**
+ * `convention/filename-naming`
+ *
+ * Enforces that the basename of a prompt file follows `kebab-case`:
+ * lowercase alphanumerics joined by single hyphens, no leading or
+ * trailing hyphens. Purely-numeric segments (e.g. `e2e-001`) are
+ * accepted.
+ *
+ * The rule fires once per file when the basename fails the check,
+ * regardless of how many invalid characters or runs of punctuation
+ * appear. The message reports the basename and suggests a fixed form.
+ */
+declare const filenameNamingRule: RuleDefinition;
+export default filenameNamingRule;
+//# sourceMappingURL=filename-naming.d.ts.map

package/dist/convention/filename-naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filename-naming.d.ts","sourceRoot":"","sources":["../../src/convention/filename-naming.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAGxD;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,kBAAkB,EAAE,cAsBxB,CAAA;AAcF,eAAe,kBAAkB,CAAA"}

package/dist/convention/filename-naming.js

@@ -0,0 +1,50 @@
+import { defineRule } from "@prompt-lint/rule-engine";
+import { extractPathBasename, isKebabCaseBasename } from "../helpers/index.js";
+/**
+ * `convention/filename-naming`
+ *
+ * Enforces that the basename of a prompt file follows `kebab-case`:
+ * lowercase alphanumerics joined by single hyphens, no leading or
+ * trailing hyphens. Purely-numeric segments (e.g. `e2e-001`) are
+ * accepted.
+ *
+ * The rule fires once per file when the basename fails the check,
+ * regardless of how many invalid characters or runs of punctuation
+ * appear. The message reports the basename and suggests a fixed form.
+ */
+const filenameNamingRule = defineRule({
+    id: "convention/filename-naming",
+    description: "Enforces `kebab-case` naming for prompt files.",
+    defaultSeverity: "info",
+    options: Object.freeze([]),
+    check: ({ file, report }) => {
+        const basename = extractPathBasename(file.path);
+        if (isKebabCaseBasename(basename)) {
+            return { findings: [] };
+        }
+        const suggested = toKebabCase(basename);
+        report({
+            message: `Prompt file basename \`${basename}\` is not kebab-case.`,
+            severity: "info",
+            suggestions: [
+                suggested.length > 0
+                    ? `Rename the file to \`${suggested}.prompt.md\`.`
+                    : "Choose a kebab-case name made of lowercase alphanumerics and single hyphens.",
+            ],
+        });
+        return { findings: [] };
+    },
+});
+function toKebabCase(input) {
+    // Insert hyphens at camelCase boundaries: aB -> a-B, ABc -> A-Bc, etc.
+    const withSeparators = input
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2");
+    const lowered = withSeparators.toLowerCase();
+    const replaced = lowered.replace(/[^a-z0-9]+/g, "-");
+    const trimmed = replaced.replace(/^-+|-+$/g, "");
+    const collapsed = trimmed.replace(/-+/g, "-");
+    return collapsed;
+}
+export default filenameNamingRule;
+//# sourceMappingURL=filename-naming.js.map

package/dist/convention/filename-naming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filename-naming.js","sourceRoot":"","sources":["../../src/convention/filename-naming.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAE9E;;;;;;;;;;;GAWG;AACH,MAAM,kBAAkB,GAAmB,UAAU,CAAC;IACpD,EAAE,EAAE,4BAA4B;IAChC,WAAW,EAAE,gDAAgD;IAC7D,eAAe,EAAE,MAAM;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;IAC1B,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE;QAC1B,MAAM,QAAQ,GAAG,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAC/C,IAAI,mBAAmB,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClC,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAA;QACzB,CAAC;QACD,MAAM,SAAS,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAA;QACvC,MAAM,CAAC;YACL,OAAO,EAAE,0BAA0B,QAAQ,uBAAuB;YAClE,QAAQ,EAAE,MAAM;YAChB,WAAW,EAAE;gBACX,SAAS,CAAC,MAAM,GAAG,CAAC;oBAClB,CAAC,CAAC,wBAAwB,SAAS,eAAe;oBAClD,CAAC,CAAC,8EAA8E;aACnF;SACF,CAAC,CAAA;QACF,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAA;IACzB,CAAC;CACF,CAAC,CAAA;AAEF,SAAS,WAAW,CAAC,KAAa;IAChC,uEAAuE;IACvE,MAAM,cAAc,GAAG,KAAK;SACzB,OAAO,CAAC,oBAAoB,EAAE,OAAO,CAAC;SACtC,OAAO,CAAC,uBAAuB,EAAE,OAAO,CAAC,CAAA;IAC5C,MAAM,OAAO,GAAG,cAAc,CAAC,WAAW,EAAE,CAAA;IAC5C,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC,CAAA;IACpD,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAA;IAChD,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;IAC7C,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,eAAe,kBAAkB,CAAA"}

package/dist/cost/high-token-estimate.d.ts

@@ -0,0 +1,4 @@
+import type { RuleDefinition } from "@prompt-lint/types";
+declare const highTokenEstimateRule: RuleDefinition;
+export default highTokenEstimateRule;
+//# sourceMappingURL=high-token-estimate.d.ts.map

package/dist/cost/high-token-estimate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"high-token-estimate.d.ts","sourceRoot":"","sources":["../../src/cost/high-token-estimate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAW,cAAc,EAAc,MAAM,oBAAoB,CAAA;AAqD7E,QAAA,MAAM,qBAAqB,EAAE,cA2B3B,CAAA;AAEF,eAAe,qBAAqB,CAAA"}

package/dist/cost/high-token-estimate.js

@@ -0,0 +1,51 @@
+import { defineRule } from "@prompt-lint/rule-engine";
+import { estimateTokens } from "../helpers/index.js";
+const HIGH_TOKEN_OPTIONS = Object.freeze([
+    Object.freeze({
+        name: "maxTokens",
+        type: "number",
+        default: 2000,
+        description: "Maximum allowed tokens before the rule fires.",
+    }),
+]);
+function readMaxTokens(options) {
+    const raw = options.maxTokens;
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+        return raw;
+    }
+    return 2000;
+}
+const findingShapeFor = (message, severity) => ({
+    message,
+    severity,
+    suggestions: [
+        "Trim the prompt body to focus on the essential instructions.",
+        "Split the prompt into smaller reusable components referenced by the main prompt.",
+        "Raise the `maxTokens` threshold if the long prompt is intentional.",
+    ],
+});
+const highTokenEstimateRule = defineRule({
+    id: "cost/high-token-estimate",
+    description: "Estimates the body token count and flags prompts that exceed the configured threshold.",
+    defaultSeverity: "warning",
+    options: HIGH_TOKEN_OPTIONS,
+    check: ({ file, options, report }) => {
+        const cfg = options;
+        const maxTokens = cfg.maxTokens !== undefined ? cfg.maxTokens : readMaxTokens(options);
+        if (typeof maxTokens !== "number" || !Number.isFinite(maxTokens)) {
+            return { findings: [] };
+        }
+        if (maxTokens <= 0) {
+            return { findings: [] };
+        }
+        const estimate = estimateTokens(file.body);
+        if (estimate > maxTokens) {
+            report({
+                ...findingShapeFor(`Prompt body is estimated at ${estimate} tokens, exceeding the configured maximum of ${maxTokens}.`, "warning"),
+            });
+        }
+        return { findings: [] };
+    },
+});
+export default highTokenEstimateRule;
+//# sourceMappingURL=high-token-estimate.js.map

package/dist/cost/high-token-estimate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"high-token-estimate.js","sourceRoot":"","sources":["../../src/cost/high-token-estimate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAsBpD,MAAM,kBAAkB,GAA0B,MAAM,CAAC,MAAM,CAAC;IAC9D,MAAM,CAAC,MAAM,CAAC;QACZ,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,IAAI;QACb,WAAW,EAAE,+CAA+C;KAC7D,CAAC;CACH,CAAC,CAAA;AAEF,SAAS,aAAa,CAAC,OAA0C;IAC/D,MAAM,GAAG,GAAG,OAAO,CAAC,SAAS,CAAA;IAC7B,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACpD,OAAO,GAAG,CAAA;IACZ,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAED,MAAM,eAAe,GAAG,CACtB,OAAe,EACf,QAA6B,EACoB,EAAE,CAAC,CAAC;IACrD,OAAO;IACP,QAAQ;IACR,WAAW,EAAE;QACX,8DAA8D;QAC9D,kFAAkF;QAClF,oEAAoE;KACrE;CACF,CAAC,CAAA;AAEF,MAAM,qBAAqB,GAAmB,UAAU,CAAC;IACvD,EAAE,EAAE,0BAA0B;IAC9B,WAAW,EACT,wFAAwF;IAC1F,eAAe,EAAE,SAAS;IAC1B,OAAO,EAAE,kBAAkB;IAC3B,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE;QACnC,MAAM,GAAG,GAAG,OAA4C,CAAA;QACxD,MAAM,SAAS,GAAG,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAA;QACtF,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;YACjE,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAA;QACzB,CAAC;QACD,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;YACnB,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAA;QACzB,CAAC;QAED,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAC1C,IAAI,QAAQ,GAAG,SAAS,EAAE,CAAC;YACzB,MAAM,CAAC;gBACL,GAAG,eAAe,CAChB,+BAA+B,QAAQ,gDAAgD,SAAS,GAAG,EACnG,SAAS,CACV;aACF,CAAC,CAAA;QACJ,CAAC;QACD,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAA;IACzB,CAAC;CACF,CAAC,CAAA;AAEF,eAAe,qBAAqB,CAAA"}

package/dist/generated/manifest.d.ts

@@ -0,0 +1,19 @@
+import type { RuleOption, Severity } from "@prompt-lint/types";
+export interface RuleManifestEntry {
+    readonly id: string;
+    readonly category: "structure" | "cost" | "security" | "quality" | "convention";
+    readonly description: string;
+    readonly severity: Severity;
+    readonly autoFixable: boolean;
+    readonly options: readonly RuleOption[];
+}
+/**
+ * The full V1 catalog. The order here is the order shown by `--list-rules`
+ * and in the docs.
+ *
+ * Kept in a separate file so `index.ts` can focus on the public API and the
+ * implementation list. The structural copy of this data is locked in by the
+ * `assertManifestOrder` runtime guard in `index.ts`.
+ */
+export declare const RULES_MANIFEST: readonly RuleManifestEntry[];
+//# sourceMappingURL=manifest.d.ts.map

package/dist/generated/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/generated/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAE9D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,GAAG,YAAY,CAAA;IAC/E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAA;CACxC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,iBAAiB,EA6FrD,CAAA"}

package/dist/generated/manifest.js

@@ -0,0 +1,98 @@
+/**
+ * The full V1 catalog. The order here is the order shown by `--list-rules`
+ * and in the docs.
+ *
+ * Kept in a separate file so `index.ts` can focus on the public API and the
+ * implementation list. The structural copy of this data is locked in by the
+ * `assertManifestOrder` runtime guard in `index.ts`.
+ */
+export const RULES_MANIFEST = Object.freeze([
+    {
+        id: "structure/missing-model",
+        category: "structure",
+        description: "Detects prompt files without a `model` field in their frontmatter.",
+        severity: "warning",
+        autoFixable: false,
+        options: [],
+    },
+    {
+        id: "structure/missing-description",
+        category: "structure",
+        description: "Detects prompt files without a `description` field in their frontmatter.",
+        severity: "warning",
+        autoFixable: false,
+        options: [],
+    },
+    {
+        id: "structure/unused-variable",
+        category: "structure",
+        description: "Flags variables defined in frontmatter but never referenced in the prompt body.",
+        severity: "warning",
+        autoFixable: false,
+        options: [],
+    },
+    {
+        id: "structure/undefined-variable",
+        category: "structure",
+        description: "Flags variables referenced in the prompt body but not declared in frontmatter.",
+        severity: "error",
+        autoFixable: false,
+        options: [],
+    },
+    {
+        id: "cost/high-token-estimate",
+        category: "cost",
+        description: "Estimates the body token count and flags prompts that exceed the configured threshold.",
+        severity: "warning",
+        autoFixable: false,
+        options: [
+            {
+                name: "maxTokens",
+                type: "number",
+                default: 2000,
+                description: "Maximum allowed tokens before the rule fires.",
+            },
+        ],
+    },
+    {
+        id: "security/pii-pattern",
+        category: "security",
+        description: "Detects common PII patterns (email, phone, SSN-shaped digits, credit-card-shaped numbers) in prompt bodies.",
+        severity: "error",
+        autoFixable: false,
+        options: [],
+    },
+    {
+        id: "security/instruction-override-pattern",
+        category: "security",
+        description: "Flags prompt bodies containing instruction-override phrasing or that encourage such phrasing.",
+        severity: "warning",
+        autoFixable: false,
+        options: [],
+    },
+    {
+        id: "quality/missing-output-schema",
+        category: "quality",
+        description: "Flags prompts that request structured data without an accompanying JSON Schema in frontmatter.",
+        severity: "warning",
+        autoFixable: false,
+        options: [],
+    },
+    {
+        id: "quality/vague-quantifier-language",
+        category: "quality",
+        description: 'Flags vague quantifier phrases (e.g., "a few", "various", "etc.", "and so on") in prompt bodies.',
+        severity: "info",
+        autoFixable: false,
+        options: [],
+    },
+    {
+        id: "convention/filename-naming",
+        category: "convention",
+        description: "Enforces `kebab-case` naming for prompt files.",
+        severity: "info",
+        autoFixable: false,
+        options: [],
+    },
+]);
+//# sourceMappingURL=manifest.js.map

package/dist/generated/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../../src/generated/manifest.ts"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,cAAc,GAAiC,MAAM,CAAC,MAAM,CAAC;IACxE;QACE,EAAE,EAAE,yBAAyB;QAC7B,QAAQ,EAAE,WAAW;QACrB,WAAW,EAAE,oEAAoE;QACjF,QAAQ,EAAE,SAAS;QACnB,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,EAAE;KACZ;IACD;QACE,EAAE,EAAE,+BAA+B;QACnC,QAAQ,EAAE,WAAW;QACrB,WAAW,EAAE,0EAA0E;QACvF,QAAQ,EAAE,SAAS;QACnB,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,EAAE;KACZ;IACD;QACE,EAAE,EAAE,2BAA2B;QAC/B,QAAQ,EAAE,WAAW;QACrB,WAAW,EAAE,iFAAiF;QAC9F,QAAQ,EAAE,SAAS;QACnB,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,EAAE;KACZ;IACD;QACE,EAAE,EAAE,8BAA8B;QAClC,QAAQ,EAAE,WAAW;QACrB,WAAW,EAAE,gFAAgF;QAC7F,QAAQ,EAAE,OAAO;QACjB,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,EAAE;KACZ;IACD;QACE,EAAE,EAAE,0BAA0B;QAC9B,QAAQ,EAAE,MAAM;QAChB,WAAW,EACT,wFAAwF;QAC1F,QAAQ,EAAE,SAAS;QACnB,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE;YACP;gBACE,IAAI,EAAE,WAAW;gBACjB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,IAAI;gBACb,WAAW,EAAE,+CAA+C;aAC7D;SACF;KACF;IACD;QACE,EAAE,EAAE,sBAAsB;QAC1B,QAAQ,EAAE,UAAU;QACpB,WAAW,EACT,6GAA6G;QAC/G,QAAQ,EAAE,OAAO;QACjB,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,EAAE;KACZ;IACD;QACE,EAAE,EAAE,uCAAuC;QAC3C,QAAQ,EAAE,UAAU;QACpB,WAAW,EACT,+FAA+F;QACjG,QAAQ,EAAE,SAAS;QACnB,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,EAAE;KACZ;IACD;QACE,EAAE,EAAE,+BAA+B;QACnC,QAAQ,EAAE,SAAS;QACnB,WAAW,EACT,gGAAgG;QAClG,QAAQ,EAAE,SAAS;QACnB,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,EAAE;KACZ;IACD;QACE,EAAE,EAAE,mCAAmC;QACvC,QAAQ,EAAE,SAAS;QACnB,WAAW,EACT,kGAAkG;QACpG,QAAQ,EAAE,MAAM;QAChB,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,EAAE;KACZ;IACD;QACE,EAAE,EAAE,4BAA4B;QAChC,QAAQ,EAAE,YAAY;QACtB,WAAW,EAAE,gDAAgD;QAC7D,QAAQ,EAAE,MAAM;QAChB,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,EAAE;KACZ;CACF,CAAC,CAAA"}

package/dist/helpers/filename.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Filename helpers used by `convention/filename-naming`.
+ *
+ * The rule operates on the basename of the prompt file's logical path
+ * (which is repository-relative and uses forward slashes). The full
+ * path is ignored so this rule works the same in monorepos and in
+ * `os`-specific layouts.
+ */
+export declare function extractPathBasename(path: string): string;
+/**
+ * Return `true` if `basename` is a valid kebab-case token: lowercase
+ * alphanumerics joined by single hyphens, no leading or trailing hyphen,
+ * no underscores, no spaces, no unicode letters.
+ *
+ * The convention allows purely numeric segments (e.g. `e2e-001`) and
+ * single-word names (e.g. `summarize`).
+ */
+export declare function isKebabCaseBasename(basename: string): boolean;
+//# sourceMappingURL=filename.d.ts.map

package/dist/helpers/filename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filename.d.ts","sourceRoot":"","sources":["../../src/helpers/filename.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA4BH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAUxD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAG7D"}

package/dist/helpers/filename.js

@@ -0,0 +1,59 @@
+/**
+ * Filename helpers used by `convention/filename-naming`.
+ *
+ * The rule operates on the basename of the prompt file's logical path
+ * (which is repository-relative and uses forward slashes). The full
+ * path is ignored so this rule works the same in monorepos and in
+ * `os`-specific layouts.
+ */
+const KEBAB_CASE_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/**
+ * Extract the basename (without recognized formatter extensions) from a
+ * normalized prompt path.
+ *
+ * `prompt.md` / `prompt.ts` / `prompt.json` are the only extensions the
+ * V1 engine understands, so the helper strips exactly one of those if
+ * present. Files that match none of those extensions are returned
+ * unchanged (the caller can then decide what to do).
+ *
+ * @example
+ *   extractPathBasename("prompts/greet-user.prompt.md") // "greet-user"
+ *   extractPathBasename("examples/My-Prompt.prompt.md") // "My-Prompt"
+ *   extractPathBasename("foo.bar/baz")                 // "baz"
+ *   extractPathBasename("noext")                       // "noext"
+ */
+const KNOWN_PROMPT_EXTENSIONS = [
+    "prompt.md",
+    "prompt.ts",
+    "prompt.json",
+    "md",
+    "ts",
+    "json",
+];
+export function extractPathBasename(path) {
+    const normalized = path.replaceAll("\\", "/");
+    const lastSlash = normalized.lastIndexOf("/");
+    const tail = lastSlash === -1 ? normalized : normalized.slice(lastSlash + 1);
+    for (const ext of KNOWN_PROMPT_EXTENSIONS) {
+        if (!tail.endsWith(`.${ext}`))
+            continue;
+        const without = tail.slice(0, -1 * (ext.length + 1));
+        if (without.length > 0)
+            return without;
+    }
+    return tail;
+}
+/**
+ * Return `true` if `basename` is a valid kebab-case token: lowercase
+ * alphanumerics joined by single hyphens, no leading or trailing hyphen,
+ * no underscores, no spaces, no unicode letters.
+ *
+ * The convention allows purely numeric segments (e.g. `e2e-001`) and
+ * single-word names (e.g. `summarize`).
+ */
+export function isKebabCaseBasename(basename) {
+    if (basename.length === 0)
+        return false;
+    return KEBAB_CASE_RE.test(basename);
+}
+//# sourceMappingURL=filename.js.map

package/dist/helpers/filename.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filename.js","sourceRoot":"","sources":["../../src/helpers/filename.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,aAAa,GAAG,4BAA4B,CAAA;AAElD;;;;;;;;;;;;;;GAcG;AACH,MAAM,uBAAuB,GAAG;IAC9B,WAAW;IACX,WAAW;IACX,aAAa;IACb,IAAI;IACJ,IAAI;IACJ,MAAM;CACE,CAAA;AAEV,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IAC7C,MAAM,SAAS,GAAG,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;IAC7C,MAAM,IAAI,GAAG,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAA;IAC5E,KAAK,MAAM,GAAG,IAAI,uBAAuB,EAAE,CAAC;QAC1C,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,GAAG,EAAE,CAAC;YAAE,SAAQ;QACvC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAA;QACpD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,OAAO,CAAA;IACxC,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAgB;IAClD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IACvC,OAAO,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;AACrC,CAAC"}

package/dist/helpers/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Reusable helpers used across the built-in rule implementations.
+ *
+ * The helper layer exists so that rule files stay small, single-purpose,
+ * and easy to audit. Every helper exported here is pure and stateless so
+ * callers can compose them freely from `RuleContext`.
+ */
+export { estimateTokens } from "./tokens.js";
+export { collectBodyVariables, collectDeclaredVariables, findVariableOccurrences, isVariableMissing, } from "./variables.js";
+export { extractPathBasename, isKebabCaseBasename } from "./filename.js";
+export { compileWordPattern, compileWordRegex, findAllMatches } from "./regex.js";
+export { PII_PATTERNS, detectPiiMatches, } from "./pii.js";
+export { INSTRUCTION_OVERRIDE_PATTERNS, findInstructionOverrideMatches, } from "./instruction-override.js";
+export { VAGUE_QUANTIFIER_TERMS, findVagueQuantifierMatches } from "./vague-quantifiers.js";
+export { STRUCTURED_DATA_KEYWORDS, hasStructuredDataKeyword, } from "./structured-data.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EACL,oBAAoB,EACpB,wBAAwB,EACxB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACxE,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AACjF,OAAO,EACL,YAAY,EACZ,gBAAgB,GACjB,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAA;AAC3F,OAAO,EACL,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,sBAAsB,CAAA"}

package/dist/helpers/index.js

@@ -0,0 +1,16 @@
+/**
+ * Reusable helpers used across the built-in rule implementations.
+ *
+ * The helper layer exists so that rule files stay small, single-purpose,
+ * and easy to audit. Every helper exported here is pure and stateless so
+ * callers can compose them freely from `RuleContext`.
+ */
+export { estimateTokens } from "./tokens.js";
+export { collectBodyVariables, collectDeclaredVariables, findVariableOccurrences, isVariableMissing, } from "./variables.js";
+export { extractPathBasename, isKebabCaseBasename } from "./filename.js";
+export { compileWordPattern, compileWordRegex, findAllMatches } from "./regex.js";
+export { PII_PATTERNS, detectPiiMatches, } from "./pii.js";
+export { INSTRUCTION_OVERRIDE_PATTERNS, findInstructionOverrideMatches, } from "./instruction-override.js";
+export { VAGUE_QUANTIFIER_TERMS, findVagueQuantifierMatches } from "./vague-quantifiers.js";
+export { STRUCTURED_DATA_KEYWORDS, hasStructuredDataKeyword, } from "./structured-data.js";
+//# sourceMappingURL=index.js.map

package/dist/helpers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EACL,oBAAoB,EACpB,wBAAwB,EACxB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACxE,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AACjF,OAAO,EACL,YAAY,EACZ,gBAAgB,GACjB,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAA;AAC3F,OAAO,EACL,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,sBAAsB,CAAA"}

package/dist/helpers/instruction-override.d.ts

@@ -0,0 +1,28 @@
+import type { RegexMatch } from "./regex.js";
+/**
+ * Patterns that detect prompt-injection-style instruction overrides.
+ *
+ * These heuristics focus on the *language* an attacker would use to ask
+ * the model to disregard earlier instructions. They are intentionally
+ * conservative — a low-quality match should not block legitimate prompts.
+ *
+ * Each entry contains a `pattern` (regex) and a `hint` value used in
+ * the rule message.
+ */
+export interface InstructionOverridePattern {
+    readonly id: string;
+    readonly description: string;
+    readonly pattern: RegExp;
+}
+export declare const INSTRUCTION_OVERRIDE_PATTERNS: readonly InstructionOverridePattern[];
+export interface InstructionOverrideMatch extends RegexMatch {
+    readonly id: string;
+    readonly description: string;
+}
+/**
+ * Scan `body` for any instruction-override phrasing. Returns matches in
+ * pattern-definition order; duplicates within a single pattern are
+ * preserved so the caller can decide whether to dedupe.
+ */
+export declare function findInstructionOverrideMatches(body: string): readonly InstructionOverrideMatch[];
+//# sourceMappingURL=instruction-override.d.ts.map

package/dist/helpers/instruction-override.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-override.d.ts","sourceRoot":"","sources":["../../src/helpers/instruction-override.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAG5C;;;;;;;;;GASG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED,eAAO,MAAM,6BAA6B,EAAE,SAAS,0BAA0B,EA8B7E,CAAA;AAEF,MAAM,WAAW,wBAAyB,SAAQ,UAAU;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,wBAAwB,EAAE,CAQhG"}

package/dist/helpers/instruction-override.js

@@ -0,0 +1,43 @@
+import { findAllMatches } from "./regex.js";
+export const INSTRUCTION_OVERRIDE_PATTERNS = Object.freeze([
+    {
+        id: "disregard-previous",
+        description: "Asks the model to ignore or disregard prior instructions",
+        pattern: /\b(?:ignore|disregard|forget|override|skip|bypass)\b[\s\S]{0,40}\b(?:previous|prior|above|earlier|initial|original|preceding|system)\b[\s\S]{0,30}\b(?:instructions?|prompts?|rules?|directives?|context|guidelines?)\b/iu,
+    },
+    {
+        id: "reveal-system",
+        description: "Attempts to expose the system prompt or hidden prompt",
+        pattern: /\b(?:reveal|show|display|print|leak|expose|share|output|repeat|echo|dump|tell\s+me)\b[\s\S]{0,40}\b(?:system|hidden|original|initial|internal|secret|underlying|full)\b[\s\S]{0,30}\b(?:prompt|instructions?|message|context|rules?)\b/iu,
+    },
+    {
+        id: "act-as-privileged",
+        description: "Impersonates a privileged role to bypass safeguards",
+        pattern: /\b(?:act|behave|operate|run|pretend)\s+as\s+(?:if\s+you\s+(?:were|are)\s+)?(?:a\s+|an\s+|the\s+)?(?:developer|admin|root|jailbroken|unrestricted|unfiltered|unmoderated|uncensored|privileged|supervisor|operator)\b/iu,
+    },
+    {
+        id: "do-anything-now",
+        description: "References the well-known 'DAN'-style jailbreak naming",
+        pattern: /\b(?:do\s+anything\s+now|d\.?a\.?n\.?\s+mode|jailbroken|jailbreak\s+mode)\b/iu,
+    },
+    {
+        id: "ignore-safety",
+        description: "Instructs the model to ignore safety or policy filters",
+        pattern: /\b(?:ignore|disable|turn\s+off|bypass|remove|skip|do\s+not\s+(?:apply|use))\b[\s\S]{0,40}\b(?:safety|content|policy|policies|filters?|guardrails?|restrictions?|moderation)\b/iu,
+    },
+]);
+/**
+ * Scan `body` for any instruction-override phrasing. Returns matches in
+ * pattern-definition order; duplicates within a single pattern are
+ * preserved so the caller can decide whether to dedupe.
+ */
+export function findInstructionOverrideMatches(body) {
+    const out = [];
+    for (const entry of INSTRUCTION_OVERRIDE_PATTERNS) {
+        for (const m of findAllMatches(entry.pattern, body)) {
+            out.push({ ...m, id: entry.id, description: entry.description });
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=instruction-override.js.map

package/dist/helpers/instruction-override.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-override.js","sourceRoot":"","sources":["../../src/helpers/instruction-override.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAkB3C,MAAM,CAAC,MAAM,6BAA6B,GAA0C,MAAM,CAAC,MAAM,CAAC;IAChG;QACE,EAAE,EAAE,oBAAoB;QACxB,WAAW,EAAE,0DAA0D;QACvE,OAAO,EACL,2NAA2N;KAC9N;IACD;QACE,EAAE,EAAE,eAAe;QACnB,WAAW,EAAE,uDAAuD;QACpE,OAAO,EACL,0OAA0O;KAC7O;IACD;QACE,EAAE,EAAE,mBAAmB;QACvB,WAAW,EAAE,qDAAqD;QAClE,OAAO,EACL,wNAAwN;KAC3N;IACD;QACE,EAAE,EAAE,iBAAiB;QACrB,WAAW,EAAE,wDAAwD;QACrE,OAAO,EAAE,+EAA+E;KACzF;IACD;QACE,EAAE,EAAE,eAAe;QACnB,WAAW,EAAE,wDAAwD;QACrE,OAAO,EACL,iLAAiL;KACpL;CACF,CAAC,CAAA;AAOF;;;;GAIG;AACH,MAAM,UAAU,8BAA8B,CAAC,IAAY;IACzD,MAAM,GAAG,GAA+B,EAAE,CAAA;IAC1C,KAAK,MAAM,KAAK,IAAI,6BAA6B,EAAE,CAAC;QAClD,KAAK,MAAM,CAAC,IAAI,cAAc,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC;YACpD,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,CAAA;QAClE,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/dist/helpers/pii.d.ts

@@ -0,0 +1,31 @@
+import type { RegexMatch } from "./regex.js";
+/**
+ * Patterns for detecting personally-identifiable information (PII) inside
+ * prompt bodies. The rule fires once per **unique kind** of detection
+ * (e.g. one `email`, one `phone`) so the configured severity is not
+ * multiplied by repetition in tests.
+ *
+ * Each pattern uses non-greedy matching with unicode-aware boundaries.
+ * URLs containing PII (e.g. `mailto:` links) intentionally still match
+ * because the rule targets raw payload bytes, not transport.
+ *
+ * Each pattern is exposed via {@link PII_PATTERNS} so reporters can
+ * surface the matched pattern type in the message.
+ */
+export declare const PII_PATTERNS: {
+    readonly email: RegExp;
+    readonly phone: RegExp;
+    readonly ssn: RegExp;
+    readonly creditCard: RegExp;
+};
+export type PiiKind = keyof typeof PII_PATTERNS;
+export interface PiiMatch extends RegexMatch {
+    readonly kind: PiiKind;
+}
+/**
+ * Detect all PII matches in `body`. Returns one entry per pattern kind.
+ * Duplicate matches of the same kind are kept so the rule implementation
+ * can decide whether to dedupe.
+ */
+export declare function detectPiiMatches(body: string): readonly PiiMatch[];
+//# sourceMappingURL=pii.d.ts.map

package/dist/helpers/pii.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pii.d.ts","sourceRoot":"","sources":["../../src/helpers/pii.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAG5C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;;;;;CAKf,CAAA;AAEV,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,YAAY,CAAA;AAE/C,MAAM,WAAW,QAAS,SAAQ,UAAU;IAC1C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CACvB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE,CASlE"}