@syv-ai/rulecast 0.1.1 → 0.2.0

package/dist/chunk-ZEFEQKG5.js

@@ -0,0 +1,937 @@
+// src/core/detection/per-rule.ts
+import { readFile, stat } from "fs/promises";
+import path from "path";
+
+// src/core/errors.ts
+var DeadlineError = class extends Error {
+};
+function isNotFound(error) {
+  return error instanceof Error && error.code === "ENOENT";
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function formatZodError(error) {
+  return error.issues.map((issue) => `${issue.path.length ? issue.path.join(".") : "(root)"}: ${issue.message}`).join("; ");
+}
+
+// src/core/detection/per-rule.ts
+function perRule(detect) {
+  return async (input) => {
+    const result = { findings: [], errors: [] };
+    await Promise.all(
+      input.rules.map(async (rule) => {
+        try {
+          for (const match of await detect(rule, input)) result.findings.push({ rule: rule.id, match });
+        } catch (error) {
+          if (error instanceof DeadlineError || input.signal.aborted || Date.now() > input.deadlineAt) throw error;
+          result.errors.push({ rule: rule.id, message: errorMessage(error) });
+        }
+      })
+    );
+    return result;
+  };
+}
+async function readSourceFile(cwd, file) {
+  try {
+    return await readFile(path.resolve(cwd, file), "utf8");
+  } catch (error) {
+    if (isNotFound(error)) return null;
+    throw error;
+  }
+}
+async function fileBytes(cwd, file) {
+  try {
+    return (await stat(path.resolve(cwd, file))).size;
+  } catch {
+    return null;
+  }
+}
+
+// src/detectors/llm/models.ts
+var ALIASES = {
+  haiku: {
+    "claude-code": "haiku",
+    anthropic: "claude-haiku-4-5-20251001",
+    opencode: "anthropic/claude-haiku-4-5-20251001"
+  },
+  sonnet: { "claude-code": "sonnet", anthropic: "claude-sonnet-5", opencode: "anthropic/claude-sonnet-5" },
+  opus: { "claude-code": "opus", anthropic: "claude-opus-5", opencode: "anthropic/claude-opus-5" },
+  fable: { "claude-code": "fable", anthropic: "claude-fable-5-1", opencode: "anthropic/claude-fable-5-1" }
+};
+var MODEL_ALIASES = Object.keys(ALIASES);
+function resolveModel(model, provider) {
+  const alias = ALIASES[model];
+  if (alias === void 0) return model;
+  return alias[provider] ?? null;
+}
+
+// src/detectors/llm/providers/types.ts
+import { z } from "zod";
+var responseSchema = z.object({
+  findings: z.array(
+    z.object({
+      rule: z.string(),
+      line: z.number().int().positive(),
+      /** The model's quote of the line. Asked for because quoting sharpens the line number; never rendered. */
+      text: z.string().optional(),
+      reason: z.string()
+    })
+  )
+});
+var FINDINGS_SCHEMA = {
+  type: "object",
+  properties: {
+    findings: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          rule: { type: "string" },
+          line: { type: "integer" },
+          text: { type: "string" },
+          reason: { type: "string" }
+        },
+        required: ["rule", "line", "reason"]
+      }
+    }
+  },
+  required: ["findings"]
+};
+var LlmUnavailableError = class extends Error {
+};
+
+// src/detectors/llm/providers/extract.ts
+function extractFindingsJson(text) {
+  let found = null;
+  for (let start = text.indexOf("{"); start !== -1; start = text.indexOf("{", start + 1)) {
+    const end = objectEnd(text, start);
+    if (end === -1) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(text.slice(start, end));
+    } catch {
+      continue;
+    }
+    if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.findings)) {
+      found = parsed;
+      start = end - 1;
+    }
+  }
+  return found;
+}
+function objectEnd(text, start) {
+  let depth = 0;
+  let inString = false;
+  for (let i = start; i < text.length; i++) {
+    const char = text[i];
+    if (inString) {
+      if (char === "\\") i++;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') inString = true;
+    else if (char === "{") depth++;
+    else if (char === "}" && --depth === 0) return i + 1;
+  }
+  return -1;
+}
+
+// src/detectors/llm/providers/http.ts
+function endpoint(baseUrl, fallback, path7) {
+  return `${(baseUrl ?? fallback).replace(/\/+$/, "")}${path7}`;
+}
+function apiKey(request) {
+  const key = request.env[request.settings.apiKeyEnv];
+  if (!key) {
+    throw new LlmUnavailableError(
+      `${request.settings.apiKeyEnv} is not set; set it, or use the claude-code provider, which needs no API key`
+    );
+  }
+  return key;
+}
+async function postJson(url, headers, body, signal) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify(body),
+    signal
+  });
+  if (!response.ok) {
+    const detail = (await response.text().catch(() => "")).slice(0, 200);
+    const message = `${url} returned ${response.status}: ${detail}`;
+    if (response.status === 401 || response.status === 403) throw new LlmUnavailableError(message);
+    throw new Error(message);
+  }
+  return response.json();
+}
+function keyAvailability(settings, env, fallback, path7) {
+  return env[settings.apiKeyEnv] ? { ok: true, detail: endpoint(settings.baseUrl, fallback, path7) } : { ok: false, detail: `$${settings.apiKeyEnv} is not set` };
+}
+
+// src/detectors/llm/providers/anthropic.ts
+var API = "https://api.anthropic.com";
+var VERSION = "2023-06-01";
+var anthropicProvider = {
+  name: "anthropic",
+  async ask(request) {
+    const key = apiKey(request);
+    const reply = await postJson(
+      endpoint(request.settings.baseUrl, API, "/v1/messages"),
+      { "x-api-key": key, "anthropic-version": VERSION },
+      {
+        model: request.model,
+        max_tokens: 4096,
+        messages: [{ role: "user", content: request.prompt }]
+      },
+      request.signal
+    );
+    const parts = reply.content ?? [];
+    const text = parts.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+    const scanned = responseSchema.safeParse(extractFindingsJson(text));
+    if (scanned.success) return scanned.data.findings;
+    throw new Error(`the anthropic API returned no usable JSON: ${text.trim().slice(0, 200)}`);
+  },
+  available: async ({ settings, env }) => keyAvailability(settings, env, API, "/v1/messages")
+};
+
+// src/detectors/llm/providers/cli.ts
+import { spawn } from "child_process";
+import { access, constants } from "fs/promises";
+import path2 from "path";
+
+// src/core/which.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile);
+async function onPath(command, signal) {
+  try {
+    await exec("/bin/sh", ["-c", 'command -v "$1" > /dev/null', "sh", command], { signal });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/detectors/llm/providers/cli.ts
+async function resolveCli(name, root) {
+  const local = path2.join(root, "node_modules", ".bin", name);
+  try {
+    await access(local, constants.X_OK);
+    return local;
+  } catch {
+    return name;
+  }
+}
+function runCli(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      signal: options.signal,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(options.input);
+    child.on("error", (error) => {
+      reject(isNotFound(error) ? new LlmUnavailableError(`${command} is not installed`) : error);
+    });
+    child.on("close", (code) => {
+      resolve({
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8"),
+        code
+      });
+    });
+  });
+}
+async function cliAvailable(name, cwd, signal) {
+  const resolved = await resolveCli(name, cwd);
+  if (resolved !== name) return { ok: true, detail: resolved };
+  return await onPath(name, signal) ? { ok: true, detail: `${name} (PATH)` } : { ok: false, detail: `${name} is not installed` };
+}
+
+// src/detectors/llm/providers/claude-code.ts
+var SYSTEM_PROMPT = "You check one source file against a list of rules and answer only with the structured result. You never edit files, run commands or ask questions.";
+var claudeCodeProvider = {
+  name: "claude-code",
+  async ask(request) {
+    const command = await resolveCli("claude", request.cwd);
+    const args = [
+      "-p",
+      "--model",
+      request.model,
+      "--output-format",
+      "json",
+      "--json-schema",
+      JSON.stringify(FINDINGS_SCHEMA),
+      "--system-prompt",
+      SYSTEM_PROMPT,
+      "--tools",
+      "",
+      "--restricted",
+      "--strict-mcp-config",
+      "--no-session-persistence"
+    ];
+    const result = await runCli(command, args, {
+      cwd: request.cwd,
+      input: request.prompt,
+      env: request.env,
+      signal: request.signal
+    });
+    const envelope = parseJson(result.stdout);
+    if (isRecord(envelope)) {
+      if (envelope.is_error === true) {
+        throw new Error(`claude reported an error: ${firstLine(String(envelope.result ?? result.stderr))}`);
+      }
+      const structured = responseSchema.safeParse(envelope.structured_output);
+      if (structured.success) return structured.data.findings;
+      if (typeof envelope.result === "string") {
+        const fromResult = responseSchema.safeParse(parseJson(envelope.result));
+        if (fromResult.success) return fromResult.data.findings;
+        const scannedResult = responseSchema.safeParse(extractFindingsJson(envelope.result));
+        if (scannedResult.success) return scannedResult.data.findings;
+      }
+    }
+    const scanned = responseSchema.safeParse(extractFindingsJson(result.stdout));
+    if (scanned.success) return scanned.data.findings;
+    throw new Error(
+      `claude returned no usable JSON (exit ${result.code}): ${firstLine(result.stderr || result.stdout)}`
+    );
+  },
+  available: ({ cwd, signal }) => cliAvailable("claude", cwd, signal)
+};
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function firstLine(text) {
+  return text.trim().split("\n")[0]?.slice(0, 200) ?? "";
+}
+
+// src/detectors/llm/providers/openai.ts
+var API2 = "https://api.openai.com/v1";
+var openaiCompatibleProvider = {
+  name: "openai-compatible",
+  async ask(request) {
+    const key = apiKey(request);
+    const reply = await postJson(
+      endpoint(request.settings.baseUrl, API2, "/chat/completions"),
+      { authorization: `Bearer ${key}` },
+      { model: request.model, messages: [{ role: "user", content: request.prompt }] },
+      request.signal
+    );
+    const content = reply.choices?.[0]?.message?.content;
+    const text = typeof content === "string" ? content : "";
+    const scanned = responseSchema.safeParse(extractFindingsJson(text));
+    if (scanned.success) return scanned.data.findings;
+    throw new Error(`the ${request.settings.provider} API returned no usable JSON: ${text.trim().slice(0, 200)}`);
+  },
+  available: async ({ settings, env }) => keyAvailability(settings, env, API2, "/chat/completions")
+};
+
+// src/detectors/llm/providers/opencode.ts
+var PROMPT_LIMIT_BYTES = 128 * 1024;
+var opencodeProvider = {
+  name: "opencode",
+  async ask(request) {
+    const size = Buffer.byteLength(request.prompt, "utf8");
+    if (size > PROMPT_LIMIT_BYTES) {
+      throw new Error(
+        `prompt is too large for the opencode provider: ${size} bytes against a limit of ${PROMPT_LIMIT_BYTES}. Narrow the rule's files, or use a provider that takes the prompt on stdin.`
+      );
+    }
+    const command = await resolveCli("opencode", request.cwd);
+    const result = await runCli(command, ["run", "--model", request.model, "--format", "default", request.prompt], {
+      cwd: request.cwd,
+      input: "",
+      env: request.env,
+      signal: request.signal
+    });
+    const scanned = responseSchema.safeParse(extractFindingsJson(result.stdout));
+    if (scanned.success) return scanned.data.findings;
+    throw new Error(
+      `opencode returned no usable JSON (exit ${result.code}): ${firstLine2(result.stderr || result.stdout)}`
+    );
+  },
+  available: ({ cwd, signal }) => cliAvailable("opencode", cwd, signal)
+};
+function firstLine2(text) {
+  return text.trim().split("\n")[0]?.slice(0, 200) ?? "";
+}
+
+// src/detectors/llm/providers/index.ts
+var PROVIDERS = {
+  "claude-code": claudeCodeProvider,
+  opencode: opencodeProvider,
+  anthropic: anthropicProvider,
+  "openai-compatible": openaiCompatibleProvider
+};
+function providerByName(name) {
+  const provider = PROVIDERS[name];
+  if (!provider) throw new LlmUnavailableError(`the ${name} provider is not available in this build`);
+  return provider;
+}
+
+// src/core/types.ts
+var LLM_PROVIDERS = ["claude-code", "opencode", "anthropic", "openai-compatible"];
+function defaultDetectorSettings() {
+  return { llm: { provider: "claude-code", baseUrl: null, apiKeyEnv: "ANTHROPIC_API_KEY", maxFilesPerVerify: 10 } };
+}
+function emptyDelivery() {
+  return {
+    findings: [],
+    preexistingSummary: [],
+    references: [],
+    touches: [],
+    stop: null,
+    warnings: [],
+    templates: {},
+    omitted: { findings: [], rules: 0, preexisting: 0 },
+    overflowPath: null
+  };
+}
+
+// src/core/version.ts
+var VERSION2 = "0.2.0";
+function parseVersion(text) {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(text);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+function isOlder(running, minimum) {
+  const a = parseVersion(running);
+  const b = parseVersion(minimum);
+  if (!a || !b) return false;
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] < b[i];
+  }
+  return false;
+}
+
+// src/core/template.ts
+var VARIABLE = /\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
+var CORE_VARIABLES = ["file", "line", "column", "text", "rule"];
+var UnknownTemplateVariable = class extends Error {
+  constructor(variable) {
+    super(`template variable "${variable}" has no value`);
+    this.variable = variable;
+  }
+  variable;
+};
+function templateVariables(template) {
+  return [...new Set([...template.matchAll(VARIABLE)].map((match) => match[1]))];
+}
+function oneLine(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function renderTemplate(template, values) {
+  return template.replace(VARIABLE, (_, name) => {
+    const value = values[name];
+    if (value === void 0) throw new UnknownTemplateVariable(name);
+    return oneLine(value);
+  });
+}
+function templateSkeleton(template) {
+  return template.replace(VARIABLE, (_, name) => `{${name}}`);
+}
+function templateLiteralLength(template) {
+  return oneLine(template.replace(VARIABLE, "")).length;
+}
+var LOCATION_VARIABLES = /* @__PURE__ */ new Set(["file", "line", "column", "rule"]);
+function templateBindings(template) {
+  return templateVariables(template).filter((name) => !LOCATION_VARIABLES.has(name));
+}
+
+// src/core/delivery/render-agent.ts
+var GROUP_FROM = 3;
+var GROUP_MIN_LITERAL = 40;
+var MAX_LOCATION_PAD = 40;
+var WRAP = 96;
+var plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+function header(delivery) {
+  if (delivery.findings.length > 0) {
+    const rules = new Set(delivery.findings.map((finding) => finding.rule)).size + delivery.omitted.rules;
+    const files = new Set(delivery.findings.map((finding) => finding.file));
+    const where = files.size === 1 && delivery.omitted.rules === 0 ? ` in ${[...files][0]}` : "";
+    return `rulecast: ${plural(rules, "rule")} violated${where}`;
+  }
+  if (delivery.references.length > 0 || delivery.preexistingSummary.length > 0) {
+    return "rulecast: conventions for the files you are working on";
+  }
+  return null;
+}
+var repeatOf = (finding) => finding.count > 1 ? ` (\xD7${finding.count})` : "";
+function findingLines(finding) {
+  const lines = finding.message.split("\n").map((line) => `  ${line}`);
+  lines[lines.length - 1] += repeatOf(finding);
+  return lines;
+}
+var locationOf = (finding, withLine) => withLine ? `${finding.file}:${finding.line}` : finding.file;
+function bindingValue(value) {
+  const text = (value ?? "").replace(/\s+/g, " ").trim();
+  if (text === "") return "\u2014";
+  return /\s/.test(text) && !/^".*"$/.test(text) ? `"${text}"` : text;
+}
+function packed(items) {
+  const lines = [];
+  for (const item of items) {
+    const last = lines.at(-1);
+    if (last !== void 0 && last.length + 2 + item.length <= WRAP) lines[lines.length - 1] = `${last}, ${item}`;
+    else lines.push(`  ${item}`);
+  }
+  return lines;
+}
+function groupedLines(findings, template) {
+  const names = templateBindings(template);
+  const withLine = templateVariables(template).includes("line");
+  const at = (finding) => locationOf(finding, withLine);
+  const out = templateSkeleton(template).split("\n").map((line) => `  ${line}`);
+  out.push("");
+  if (names.length === 0) {
+    out.push(...packed(findings.map((finding) => `${at(finding)}${repeatOf(finding)}`)));
+    return out;
+  }
+  const width = Math.min(MAX_LOCATION_PAD, Math.max(...findings.map((finding) => at(finding).length)));
+  for (const finding of findings) {
+    const values = names.map((name) => bindingValue(finding.captures?.[name])).join("  ");
+    out.push(`  ${at(finding).padEnd(width)}  ${values}${repeatOf(finding)}`.trimEnd());
+  }
+  return out;
+}
+function referenceLines(reference) {
+  switch (reference.state) {
+    case "full":
+      return [`--- ${reference.ref} ---`, ...(reference.content ?? "").split("\n"), ""];
+    case "pointer":
+      return [`--- ${reference.ref} (provided earlier in this session) ---`];
+    case "missing":
+      return [`--- ${reference.ref} (missing) ---`];
+    case "read": {
+      const what = reference.location === void 0 ? "read this" : `read ${reference.location}`;
+      return reference.reason === "mode" ? [`--- ${reference.ref}: ${what} before continuing ---`] : [`--- ${reference.ref}: ${what} before continuing (not included, too long for this message) ---`];
+    }
+  }
+}
+function omittedFor(omitted, rule) {
+  const entry = omitted.findings.find((finding) => finding.rule === rule);
+  return { count: entry?.count ?? 0, files: entry?.files ?? 0 };
+}
+function ruleBlock(rule, findings, template, dropped, options) {
+  const shown = findings.slice(0, options.maxMatchesPerRule);
+  const hidden = findings.slice(options.maxMatchesPerRule);
+  const total = findings.length + dropped.count;
+  const grouped = template !== void 0 && total >= GROUP_FROM && templateLiteralLength(template) >= GROUP_MIN_LITERAL;
+  const severity = findings[0].severity;
+  const files = new Set(findings.map((finding) => finding.file)).size + dropped.files;
+  const out = [grouped ? `${severity} ${rule} \u2014 ${total} in ${plural(files, "file")}` : `${severity} ${rule}`];
+  if (grouped && template !== void 0) out.push(...groupedLines(shown, template));
+  else for (const finding of shown) out.push(...findingLines(finding));
+  const more = hidden.length + dropped.count;
+  if (more > 0) {
+    const moreFiles = new Set(hidden.map((finding) => finding.file)).size + dropped.files;
+    out.push(`  \u2026and ${more} more in ${plural(moreFiles, "file")}`);
+  }
+  return out;
+}
+function measureRuleBlock(rule, findings, template, options) {
+  return ruleBlock(rule, findings, template, { count: 0, files: 0 }, options).join("\n").length + 1;
+}
+function renderAgentText(delivery, options) {
+  const title = header(delivery);
+  if (title === null && delivery.warnings.length === 0) return "";
+  const out = [];
+  if (title !== null) out.push(title, "");
+  const byRule = /* @__PURE__ */ new Map();
+  for (const finding of delivery.findings) {
+    const group = byRule.get(finding.rule);
+    if (group === void 0) byRule.set(finding.rule, [finding]);
+    else group.push(finding);
+  }
+  for (const [rule, findings] of byRule) {
+    out.push(...ruleBlock(rule, findings, delivery.templates[rule], omittedFor(delivery.omitted, rule), options));
+    out.push("");
+  }
+  for (const summary of delivery.preexistingSummary) {
+    out.push(`pre-existing (not blocking): ${summary.rule} \xD7${summary.count} in ${summary.file}`);
+  }
+  if (delivery.omitted.preexisting > 0) {
+    out.push(`\u2026and ${delivery.omitted.preexisting} more pre-existing (not blocking)`);
+  }
+  if (delivery.preexistingSummary.length > 0 || delivery.omitted.preexisting > 0) out.push("");
+  for (const reference of delivery.references) out.push(...referenceLines(reference));
+  if (out.length > 0 && out.at(-1) !== "") out.push("");
+  if (delivery.warnings.length > 0) {
+    out.push("rulecast warnings:", ...delivery.warnings.map((warning) => `  - ${warning}`));
+  }
+  if (delivery.overflowPath !== null) {
+    if (out.at(-1) !== "") out.push("");
+    out.push(
+      `\u2026${plural(delivery.omitted.rules, "rule")} and the conventions they cite did not fit here.`,
+      "Every finding, with the doc sections it cites, is in:",
+      `  ${delivery.overflowPath}`
+    );
+  }
+  while (out.at(-1) === "") out.pop();
+  return out.join("\n");
+}
+
+// src/core/compile/rule.ts
+import path5 from "path";
+
+// src/core/anchors.ts
+var FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+var FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})[ \t]*$/;
+var ATX = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*$/;
+var SETEXT_1 = /^ {0,3}=+[ \t]*$/;
+var SETEXT_2 = /^ {0,3}-+[ \t]*$/;
+var LIST_ITEM = /^ {0,3}[-*+][ \t]/;
+function linesOf(markdown) {
+  return markdown.split(/\r?\n/);
+}
+function slugify(text) {
+  return text.trim().toLowerCase().replace(/[^\p{L}\p{M}\p{N}\p{Pc} -]/gu, "").replace(/ /g, "-");
+}
+function scanHeadings(markdown) {
+  const lines = linesOf(markdown);
+  const headings = [];
+  const seen = /* @__PURE__ */ new Map();
+  let fence = null;
+  const add = (level, text, line) => {
+    const base = slugify(text);
+    const count = seen.get(base) ?? 0;
+    seen.set(base, count + 1);
+    headings.push({ level, text, slug: count === 0 ? base : `${base}-${count}`, line });
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (fence) {
+      const close = line.match(FENCE_CLOSE);
+      if (close && close[1][0] === fence.char && close[1].length >= fence.length) fence = null;
+      continue;
+    }
+    const open = line.match(FENCE_OPEN);
+    if (open) {
+      fence = { char: open[1][0], length: open[1].length };
+      continue;
+    }
+    const atx = line.match(ATX);
+    if (atx) {
+      add(atx[1].length, (atx[2] ?? "").trim(), i + 1);
+      continue;
+    }
+    const next = lines[i + 1];
+    if (next === void 0 || line.trim() === "") continue;
+    if (SETEXT_1.test(next)) {
+      add(1, line.trim(), i + 1);
+      i++;
+    } else if (SETEXT_2.test(next) && !LIST_ITEM.test(line)) {
+      add(2, line.trim(), i + 1);
+      i++;
+    }
+  }
+  return headings;
+}
+function sectionRange(markdown, slug) {
+  const headings = scanHeadings(markdown);
+  const index = headings.findIndex((heading2) => heading2.slug === slug);
+  if (index === -1) return null;
+  const heading = headings[index];
+  const next = headings.slice(index + 1).find((candidate) => candidate.level <= heading.level);
+  return { slug, start: heading.line, end: next ? next.line - 1 : linesOf(markdown).length };
+}
+function sectionText(markdown, section) {
+  return linesOf(markdown).slice(section.start - 1, section.end).join("\n").trimEnd();
+}
+function sectionContains(markdown, parentSlug, childSlug) {
+  const parent = sectionRange(markdown, parentSlug);
+  const child = sectionRange(markdown, childSlug);
+  if (!parent || !child) return false;
+  return child.start >= parent.start && child.end <= parent.end;
+}
+
+// src/core/files.ts
+import path3 from "path";
+var TYPE_TABLE = {
+  ".py": ["text", "python"],
+  ".pyi": ["text", "python", "pyi"],
+  ".ts": ["text", "ts"],
+  ".mts": ["text", "ts"],
+  ".cts": ["text", "ts"],
+  ".tsx": ["text", "tsx"],
+  ".js": ["text", "javascript"],
+  ".mjs": ["text", "javascript"],
+  ".cjs": ["text", "javascript"],
+  ".jsx": ["text", "jsx"],
+  ".md": ["text", "markdown"],
+  ".mdx": ["text", "mdx"],
+  ".yaml": ["text", "yaml"],
+  ".yml": ["text", "yaml"],
+  ".json": ["text", "json"],
+  ".toml": ["text", "toml"],
+  ".css": ["text", "css"],
+  ".scss": ["text", "scss"],
+  ".html": ["text", "html"],
+  ".sh": ["text", "shell"],
+  ".sql": ["text", "sql"],
+  ".go": ["text", "go"],
+  ".rs": ["text", "rust"],
+  ".txt": ["text", "plain-text"]
+};
+var KNOWN_TAGS = /* @__PURE__ */ new Set(["file", ...Object.values(TYPE_TABLE).flat()]);
+var FILE_ONLY = /* @__PURE__ */ new Set(["file"]);
+function tagsOf(file) {
+  const tags = TYPE_TABLE[path3.posix.extname(file).toLowerCase()];
+  return tags ? /* @__PURE__ */ new Set(["file", ...tags]) : FILE_ONLY;
+}
+function compileRegex(key, source) {
+  try {
+    return new RegExp(source);
+  } catch (error) {
+    return `${key}: invalid regex: ${errorMessage(error)}`;
+  }
+}
+function compileFilter(input) {
+  const files = compileRegex("files", input.files);
+  if (typeof files === "string") return files;
+  const exclude = compileRegex("exclude", input.exclude);
+  if (typeof exclude === "string") return exclude;
+  const unknown = [...input.types, ...input.typesOr, ...input.excludeTypes].find((tag) => !KNOWN_TAGS.has(tag));
+  if (unknown !== void 0) return `unknown file type "${unknown}"`;
+  const { types, typesOr, excludeTypes } = input;
+  return (file) => {
+    if (!files.test(file) || exclude.test(file)) return false;
+    const tags = tagsOf(file);
+    return types.every((tag) => tags.has(tag)) && (typesOr.length === 0 || typesOr.some((tag) => tags.has(tag))) && !excludeTypes.some((tag) => tags.has(tag));
+  };
+}
+
+// src/core/references.ts
+import path4 from "path";
+import { z as z2 } from "zod";
+var referenceInputSchema = z2.union([
+  z2.string(),
+  z2.object({ path: z2.string(), mode: z2.enum(["inject", "read"]).optional() }).strict()
+]);
+var ReferenceSyntaxError = class extends Error {
+};
+function parseReference(input, defaultMode, root) {
+  const raw = typeof input === "string" ? input : input.path;
+  const mode = typeof input === "string" ? defaultMode : input.mode ?? defaultMode;
+  if (!raw.startsWith("@")) throw new ReferenceSyntaxError(`reference "${raw}" must start with "@"`);
+  const body = raw.slice(1);
+  const hash = body.indexOf("#");
+  const file = hash === -1 ? body : body.slice(0, hash);
+  const anchor = hash === -1 ? null : body.slice(hash + 1);
+  if (!file) throw new ReferenceSyntaxError(`reference "${raw}" has no path`);
+  if (anchor === "") throw new ReferenceSyntaxError(`reference "${raw}" has an empty anchor`);
+  if (anchor !== null && !/\.mdx?$/.test(file)) {
+    throw new ReferenceSyntaxError(`anchors are only supported in .md and .mdx files: "${raw}"`);
+  }
+  const relative = path4.posix.normalize(file);
+  if (path4.posix.isAbsolute(relative) || relative === ".." || relative.startsWith("../")) {
+    throw new ReferenceSyntaxError(`reference "${raw}" leaves its root`);
+  }
+  const suffix = anchor === null ? "" : `#${anchor}`;
+  if (root.label === null) return { ref: `${relative}${suffix}`, path: relative, anchor, mode };
+  return { ref: `${root.label}:${relative}${suffix}`, path: path4.join(root.dir, relative), anchor, mode };
+}
+
+// src/core/compile/rule.ts
+function isDetectorRule(rule) {
+  return rule.detector !== null;
+}
+function fileOf(spec) {
+  return spec.anchor === null ? spec.ref : spec.ref.slice(0, spec.ref.length - spec.anchor.length - 1);
+}
+async function compileRule(input, context) {
+  const { data } = input;
+  const minimum = data.minimum_rulecast_version;
+  if (minimum !== void 0 && isOlder(VERSION2, minimum)) {
+    return `requires rulecast ${minimum} or newer (running ${VERSION2})`;
+  }
+  let detector = null;
+  let defaultStages = ["touch"];
+  if (data.detect) {
+    const [kind, rawConfig] = Object.entries(data.detect)[0];
+    const implementation = context.registry.get(kind);
+    if (!implementation) return `unknown detector "${kind}"`;
+    const parsed = await implementation.schema.safeParseAsync(rawConfig ?? {});
+    if (!parsed.success) return `detect.${kind}: ${formatZodError(parsed.error)}`;
+    detector = { kind, config: parsed.data, captures: implementation.captures(parsed.data) };
+    defaultStages = implementation.events(parsed.data);
+  }
+  const stages = data.stages ?? context.config.defaultStages ?? defaultStages;
+  if (detector) {
+    if (data.message === void 0) return "rules with detect need a message";
+    if (!stages.includes("edit") && !stages.includes("verify")) {
+      return "stages [touch] never run the detector: add edit or verify, or remove detect";
+    }
+    if (data.refuse_write) {
+      if (context.registry.get(detector.kind)?.guards !== true) {
+        return `refuse_write needs a detector that can judge a file before it is written; ${detector.kind} cannot`;
+      }
+      if (!stages.includes("edit")) return "refuse_write needs edit among the rule's stages";
+    }
+    const known = /* @__PURE__ */ new Set([...CORE_VARIABLES, ...detector.captures]);
+    const unknown = templateVariables(data.message).find((name) => !known.has(name));
+    if (unknown) return `unknown template variable "${unknown}"`;
+  } else {
+    if (data.refuse_write) return "refuse_write needs detect: there is nothing to refuse a write for";
+    if (stages.some((stage) => stage !== "touch")) return "rules without detect need stages: [touch]";
+    if (data.message !== void 0) return "message needs detect";
+    if (!data.context?.length) return "rules without detect need context";
+  }
+  const filter = compileFilter({
+    files: data.files ?? "",
+    exclude: data.exclude ?? "^$",
+    types: data.types ?? ["file"],
+    typesOr: data.types_or ?? [],
+    excludeTypes: data.exclude_types ?? []
+  });
+  if (typeof filter === "string") return filter;
+  const references = [];
+  for (const reference of data.context ?? []) {
+    let spec;
+    try {
+      spec = parseReference(reference, context.config.context.mode, input.contextRoot);
+    } catch (error) {
+      if (error instanceof ReferenceSyntaxError) return error.message;
+      throw error;
+    }
+    const text = await context.read(path5.resolve(input.contextRoot.dir, spec.path));
+    if (text === null) return `referenced file not found: ${fileOf(spec)}`;
+    if (spec.anchor !== null && !sectionRange(text, spec.anchor)) {
+      return `anchor "#${spec.anchor}" not found in ${fileOf(spec)}`;
+    }
+    references.push(spec);
+  }
+  const { global } = context;
+  return {
+    id: data.alias ?? data.id,
+    name: data.name,
+    description: data.description ?? null,
+    source: input.source,
+    severity: data.severity ?? "error",
+    refuseWrite: data.refuse_write === true,
+    stages,
+    matches: (file) => global(file) && filter(file),
+    detector,
+    message: data.message ?? null,
+    context: references
+  };
+}
+
+// src/core/detection/cache.ts
+import { createHash, randomUUID } from "crypto";
+import { mkdir, readFile as readFile2, rename, writeFile } from "fs/promises";
+import path6 from "path";
+function memoryCache() {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    async get(key) {
+      return values.has(key) ? structuredClone(values.get(key)) : void 0;
+    },
+    async set(key, value) {
+      values.set(key, structuredClone(value));
+    }
+  };
+}
+function diskCache(dir) {
+  const fileFor = (key) => path6.join(dir, `${createHash("sha256").update(key).digest("hex")}.json`);
+  return {
+    async get(key) {
+      try {
+        return JSON.parse(await readFile2(fileFor(key), "utf8"));
+      } catch (error) {
+        if (isNotFound(error)) return void 0;
+        throw error;
+      }
+    },
+    async set(key, value) {
+      await mkdir(dir, { recursive: true });
+      const target = fileFor(key);
+      const temp = `${target}.${randomUUID()}.tmp`;
+      await writeFile(temp, JSON.stringify(value));
+      await rename(temp, target);
+    }
+  };
+}
+function detectorCacheDir(stateDir, kind) {
+  return path6.join(stateDir, "cache", kind);
+}
+
+// src/core/detection/positions.ts
+function lineStarts(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) starts.push(i + 1);
+  }
+  return starts;
+}
+function positionAt(starts, offset) {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const mid = low + high + 1 >> 1;
+    if (starts[mid] <= offset) low = mid;
+    else high = mid - 1;
+  }
+  return { line: low + 1, column: offset - starts[low] + 1 };
+}
+function offsetAt(starts, line, column, length) {
+  const index = Math.min(Math.max(line, 1), starts.length) - 1;
+  const offset = starts[index] + Math.max(column, 1) - 1;
+  return Math.min(Math.max(offset, 0), length);
+}
+
+export {
+  DeadlineError,
+  isNotFound,
+  errorMessage,
+  formatZodError,
+  perRule,
+  readSourceFile,
+  fileBytes,
+  onPath,
+  CORE_VARIABLES,
+  renderTemplate,
+  templateBindings,
+  lineStarts,
+  positionAt,
+  offsetAt,
+  MODEL_ALIASES,
+  resolveModel,
+  LlmUnavailableError,
+  providerByName,
+  referenceInputSchema,
+  LLM_PROVIDERS,
+  defaultDetectorSettings,
+  emptyDelivery,
+  VERSION2 as VERSION,
+  parseVersion,
+  isOlder,
+  measureRuleBlock,
+  renderAgentText,
+  tagsOf,
+  compileFilter,
+  scanHeadings,
+  sectionRange,
+  sectionText,
+  sectionContains,
+  isDetectorRule,
+  compileRule,
+  memoryCache,
+  diskCache,
+  detectorCacheDir
+};