@syv-ai/rulecast 0.1.0

package/dist/cli.js

@@ -0,0 +1,1664 @@
+#!/usr/bin/env node
+import {
+  ADAPTERS,
+  CONFIG_FILE,
+  LockTimeoutError,
+  MANIFEST_FILE,
+  NO_PROMPT,
+  RepoFetchError,
+  VERSION,
+  adapterByName,
+  allFiles,
+  builtinDetectors,
+  cacheHome,
+  cachedRepo,
+  cachedRepos,
+  changedFilesBetween,
+  changedFilesSince,
+  checkDetectors,
+  compile,
+  compileManifest,
+  createRegistry,
+  debugLogger,
+  defaultConfig,
+  detectorCacheDir,
+  diagnosticText,
+  diskCache,
+  ensureProjectState,
+  ensureRepo,
+  errorMessage,
+  fetchCheckout,
+  fetchingRepos,
+  fixedRepo,
+  git,
+  isNotFound,
+  memoryCache,
+  mergeBase,
+  parseConfig,
+  parseVersion,
+  projectStateDir,
+  readConfigData,
+  readManifest,
+  readSourceFile,
+  renderAgentText,
+  repoLabel,
+  runDetection,
+  runPipeline,
+  scanHeadings,
+  stagedFiles,
+  tagsOf,
+  withLock
+} from "./chunk-POEWJTZ2.js";
+import {
+  Cancelled
+} from "./chunk-K37BHCEK.js";
+
+// src/cli.ts
+import { text as readAll } from "stream/consumers";
+
+// src/commands/autoupdate.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+import { parseArgs as parseArgs2 } from "util";
+
+// src/core/config/edit.ts
+import { isMap, isScalar, isSeq, parseDocument } from "yaml";
+var FROZEN = /^\s*#\s*frozen:/;
+function quoted(value, type) {
+  if (type === "QUOTE_DOUBLE") return JSON.stringify(value);
+  if (type === "QUOTE_SINGLE") return `'${value.replaceAll("'", "''")}'`;
+  return value;
+}
+function setRevs(text, updates) {
+  if (updates.length === 0) return text;
+  const doc = parseDocument(text, { keepSourceTokens: true });
+  const repos = doc.get("repos", true);
+  if (!isSeq(repos)) throw new Error("repos must be a list");
+  const edits = [];
+  for (const update of updates) {
+    const entry = repos.items[update.index];
+    if (!isMap(entry)) throw new Error(`repos[${update.index}] is not a mapping`);
+    const rev = entry.get("rev", true);
+    if (!isScalar(rev) || !rev.range) throw new Error(`repos[${update.index}] has no rev`);
+    const [start, valueEnd] = rev.range;
+    const value = quoted(update.rev, rev.type);
+    if (entry.flow) {
+      edits.push({ start, end: valueEnd, text: value });
+      continue;
+    }
+    const newline = text.indexOf("\n", valueEnd);
+    let end = newline === -1 ? text.length : newline;
+    if (text[end - 1] === "\r") end--;
+    let tail = text.slice(valueEnd, end);
+    if (update.frozenTag !== null) tail = `  # frozen: ${update.frozenTag}`;
+    else if (FROZEN.test(tail)) tail = "";
+    edits.push({ start, end, text: value + tail });
+  }
+  let result = text;
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return result;
+}
+
+// src/core/repos/tags.ts
+import { tmpdir } from "os";
+var TAG_REF = "refs/tags/";
+var PEELED = "^{}";
+async function remoteTags(url) {
+  const result = await git(tmpdir(), ["ls-remote", "--tags", url], NO_PROMPT);
+  if (!result.ok) throw new RepoFetchError(result.stderr.trim() || `git ls-remote ${url} failed`);
+  const tags = /* @__PURE__ */ new Map();
+  for (const line2 of result.stdout.split("\n")) {
+    const [sha, ref] = line2.split("	");
+    if (!sha || !ref?.startsWith(TAG_REF)) continue;
+    const peeled = ref.endsWith(PEELED);
+    const name = ref.slice(TAG_REF.length, peeled ? -PEELED.length : void 0);
+    if (peeled || !tags.has(name)) tags.set(name, { sha, peeled });
+  }
+  return [...tags].map(([name, { sha }]) => ({ name, sha })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
+function versionOf(name) {
+  return /^v?\d+\.\d+\.\d+$/.test(name) ? parseVersion(name.replace(/^v/, "")) : null;
+}
+function latestTag(tags) {
+  let best = null;
+  for (const tag of tags) {
+    const version = versionOf(tag.name);
+    if (!version) continue;
+    if (best === null || compareVersions(version, best.version) > 0) best = { tag, version };
+  }
+  return best?.tag ?? null;
+}
+function compareVersions(a, b) {
+  return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+
+// src/commands/install.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path2 from "path";
+import { parseArgs } from "util";
+
+// src/commands/project.ts
+import { existsSync } from "fs";
+import path from "path";
+function findRoot(cwd) {
+  for (let dir = path.resolve(cwd); ; dir = path.dirname(dir)) {
+    if (existsSync(path.join(dir, CONFIG_FILE))) return dir;
+    if (path.dirname(dir) === dir) return path.resolve(cwd);
+  }
+}
+function hasProject(root) {
+  return existsSync(path.join(root, CONFIG_FILE));
+}
+function toProjectPath(root, cwd, file) {
+  const relative = path.relative(root, path.resolve(cwd, file));
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    return null;
+  }
+  return relative.split(path.sep).join("/");
+}
+
+// src/commands/usage.ts
+var UsageError = class extends Error {
+};
+
+// src/commands/install.ts
+async function readSettings(root, file) {
+  let text;
+  try {
+    text = await readFile(path2.join(root, file), "utf8");
+  } catch (error) {
+    if (isNotFound(error)) return null;
+    throw error;
+  }
+  try {
+    return { value: JSON.parse(text) };
+  } catch (error) {
+    throw new Error(`${file}: ${errorMessage(error)}`);
+  }
+}
+async function writeSettings(root, file, settings) {
+  const full = path2.join(root, file);
+  await mkdir(path2.dirname(full), { recursive: true });
+  await writeFile(full, `${JSON.stringify(settings, null, 2)}
+`);
+}
+function installOf(adapter) {
+  if (!adapter.install) throw new UsageError(`${adapter.name} has no hooks to install`);
+  return adapter.install;
+}
+function inFile(file, transform) {
+  try {
+    return transform();
+  } catch (error) {
+    throw new Error(`${file}: ${errorMessage(error)}`);
+  }
+}
+async function hooksInstalled(root, adapter, verifyMs) {
+  const install = installOf(adapter);
+  const command = install.command(existsSync2(path2.join(root, "node_modules", ".bin", "rulecast")));
+  for (const { file } of install.scopes) {
+    const current = await readSettings(root, file);
+    if (current === null) continue;
+    if (inFile(file, () => install.merge(current.value, command, verifyMs)).added.length === 0) return file;
+  }
+  return null;
+}
+async function installHooks(root, adapter, scope, verifyMs) {
+  const install = installOf(adapter);
+  const command = install.command(existsSync2(path2.join(root, "node_modules", ".bin", "rulecast")));
+  const already = await hooksInstalled(root, adapter, verifyMs);
+  if (already !== null) return { file: already, added: [] };
+  const target = install.scopes.find((candidate) => candidate.scope === scope);
+  if (!target) throw new UsageError(`${adapter.name} has no ${scope} settings`);
+  const current = (await readSettings(root, target.file))?.value ?? {};
+  const merged = inFile(target.file, () => install.merge(current, command, verifyMs));
+  await writeSettings(root, target.file, merged.settings);
+  return { file: target.file, added: merged.added };
+}
+async function uninstallHooks(root, adapter) {
+  const install = installOf(adapter);
+  const results = [];
+  for (const { file } of install.scopes) {
+    const current = await readSettings(root, file);
+    if (current === null) continue;
+    const { settings, removed } = inFile(file, () => install.remove(current.value));
+    if (removed.length === 0) continue;
+    await writeSettings(root, file, settings);
+    results.push({ file, removed });
+  }
+  return results;
+}
+function selectAdapters(names) {
+  if (names === void 0) return ADAPTERS.filter((adapter) => adapter.install !== null);
+  const known = ADAPTERS.filter((adapter) => adapter.install !== null).map((adapter) => adapter.name);
+  return names.map((name) => {
+    const adapter = adapterByName(name);
+    if (!adapter?.install) throw new UsageError(`unknown agent "${name}" (use ${known.join(", ")})`);
+    return adapter;
+  });
+}
+async function loadProjectConfig(root, command) {
+  const data = await readConfigData(root);
+  const config = data.ok ? parseConfig(data.value) : data;
+  if (!config.ok) throw new Error(`${config.message} (fix it, then run rulecast ${command} again)`);
+  return config.value;
+}
+function printInstall(io, adapter, result) {
+  io.stdout(
+    result.added.length === 0 ? `${adapter.label} hooks already installed in ${result.file}
+` : `installed ${adapter.label} hooks in ${result.file}: ${result.added.join(", ")}
+`
+  );
+}
+async function fetchMissingRepos(config, io) {
+  const home = cacheHome(io.env);
+  let ok = true;
+  for (const entry of config.repos) {
+    if (entry.repo === "local" || entry.rev === void 0) continue;
+    if (cachedRepo(home, entry.repo, entry.rev) !== null) continue;
+    const label = repoLabel(entry.repo, entry.rev);
+    try {
+      await ensureRepo(home, entry.repo, entry.rev);
+      io.stdout(`fetched ${label}
+`);
+    } catch (error) {
+      io.stderr(`rulecast: could not fetch ${label}: ${errorMessage(error)}
+`);
+      ok = false;
+    }
+  }
+  return ok;
+}
+async function installCommand(root, args, io) {
+  const { values } = parseArgs({
+    args,
+    options: { agent: { type: "string", multiple: true }, scope: { type: "string", default: "shared" } }
+  });
+  const scope = values.scope;
+  if (scope !== "shared" && scope !== "personal") {
+    throw new UsageError(`unknown scope "${scope}" (use shared, personal)`);
+  }
+  const adapters = selectAdapters(values.agent);
+  if (!hasProject(root)) throw new Error(`no ${CONFIG_FILE} in ${io.cwd} or its parents (run rulecast init)`);
+  const config = await loadProjectConfig(root, "install");
+  for (const adapter of adapters) {
+    printInstall(io, adapter, await installHooks(root, adapter, scope, config.timeouts.verifyMs));
+  }
+  return await fetchMissingRepos(config, io) ? 0 : 2;
+}
+async function uninstallCommand(root, args, io) {
+  const { values } = parseArgs({ args, options: { agent: { type: "string", multiple: true } } });
+  for (const adapter of selectAdapters(values.agent)) {
+    const results = await uninstallHooks(root, adapter);
+    if (results.length === 0) io.stdout(`no ${adapter.label} hooks to remove
+`);
+    for (const { file, removed } of results) {
+      io.stdout(`removed ${adapter.label} hooks from ${file}: ${removed.join(", ")}
+`);
+    }
+  }
+  return 0;
+}
+
+// src/commands/autoupdate.ts
+async function autoupdateCommand(root, args, io) {
+  const { values } = parseArgs2({
+    args,
+    options: { freeze: { type: "boolean", default: false }, repo: { type: "string", multiple: true } }
+  });
+  if (!hasProject(root)) throw new Error(`no ${CONFIG_FILE} in ${io.cwd} or its parents`);
+  const config = await loadProjectConfig(root, "autoupdate");
+  const only = values.repo;
+  for (const url of only ?? []) {
+    if (!config.repos.some((entry) => entry.repo === url)) throw new UsageError(`no repo "${url}" in ${CONFIG_FILE}`);
+  }
+  const updates = [];
+  let failed = false;
+  for (const [index, entry] of config.repos.entries()) {
+    if (entry.repo === "local" || entry.rev === void 0) continue;
+    if (only && !only.includes(entry.repo)) continue;
+    let latest;
+    try {
+      latest = latestTag(await remoteTags(entry.repo));
+    } catch (error) {
+      io.stderr(`rulecast: ${entry.repo}: ${errorMessage(error)}
+`);
+      failed = true;
+      continue;
+    }
+    if (latest === null) {
+      io.stdout(`${entry.repo}: no version tags
+`);
+      continue;
+    }
+    const rev = values.freeze ? latest.sha : latest.name;
+    if (rev === entry.rev) {
+      io.stdout(`${entry.repo}: already up to date
+`);
+      continue;
+    }
+    io.stdout(`${entry.repo}: updating ${entry.rev} -> ${rev}${values.freeze ? ` (frozen: ${latest.name})` : ""}
+`);
+    updates.push({ index, rev, frozenTag: values.freeze ? latest.name : null });
+  }
+  if (updates.length > 0) {
+    const file = path3.join(root, CONFIG_FILE);
+    await writeFile2(file, setRevs(await readFile2(file, "utf8"), updates));
+  }
+  return failed ? 2 : 0;
+}
+
+// src/commands/clean.ts
+import { existsSync as existsSync3 } from "fs";
+import { rm } from "fs/promises";
+import { parseArgs as parseArgs3 } from "util";
+async function cleanCommand(root, args, io) {
+  const { values } = parseArgs3({ args, options: { project: { type: "boolean", default: false } } });
+  const home = cacheHome(io.env);
+  let target = home;
+  if (values.project) {
+    if (!hasProject(root)) throw new Error(`no ${CONFIG_FILE} in ${io.cwd} or its parents`);
+    target = projectStateDir(home, root);
+  }
+  if (!existsSync3(target)) {
+    io.stdout("nothing to clean\n");
+    return 0;
+  }
+  await rm(target, { recursive: true, force: true });
+  io.stdout(`removed ${target}
+`);
+  return 0;
+}
+
+// src/commands/doctor.ts
+var CHECK_TIMEOUT_MS = 3e4;
+function line(level, what, detail) {
+  return `  ${level.padEnd(7)}  ${what}${detail === "" ? "" : ` \u2014 ${detail}`}
+`;
+}
+function naming(rules) {
+  if (rules.length === 0) return "";
+  if (rules.length <= 3) return ` (${rules.join(", ")})`;
+  return ` (${rules.slice(0, 3).join(", ")} and ${rules.length - 3} more)`;
+}
+function plural(count, noun) {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+async function doctorCommand(root, args, registry, io) {
+  if (args.length > 0) throw new UsageError(`doctor takes no arguments: ${args.join(" ")}`);
+  const home = cacheHome(io.env);
+  io.stdout("rulecast doctor\n\n");
+  if (!hasProject(root)) {
+    io.stdout(`home       ${home}
+`);
+    io.stderr(`rulecast: no ${CONFIG_FILE} in ${io.cwd} or its parents (run rulecast init)
+`);
+    return 2;
+  }
+  let errors = 0;
+  let warnings = 0;
+  const count = (level) => {
+    if (level === "error") errors++;
+    if (level === "warning") warnings++;
+  };
+  const stateDir = ensureProjectState(home, root);
+  io.stdout(`project    ${root}
+`);
+  const project = await compile({ root, registry, repos: fetchingRepos(home) });
+  const configErrors = project.diagnostics.filter((diagnostic) => diagnostic.level === "error").length;
+  const configWarnings = project.diagnostics.length - configErrors;
+  io.stdout(
+    `config     ${CONFIG_FILE} \u2014 ${plural(project.rules.length, "rule")}, ${plural(configErrors, "error")}, ${plural(configWarnings, "warning")}
+`
+  );
+  for (const diagnostic of project.diagnostics) {
+    count(diagnostic.level);
+    io.stdout(line(diagnostic.level, diagnosticText(diagnostic), ""));
+  }
+  const results = await checkDetectors({
+    project,
+    registry,
+    settings: { llm: project.config.llm },
+    env: io.env,
+    timeoutMs: CHECK_TIMEOUT_MS
+  });
+  if (results.length > 0) {
+    io.stdout("\nenvironment\n");
+    for (const result of results) {
+      count(result.level);
+      const rules = result.level === "ok" ? "" : naming(result.rules);
+      io.stdout(line(result.level, result.what, `${result.detail}${rules}`));
+    }
+  }
+  io.stdout("\nhooks\n");
+  for (const adapter of ADAPTERS) {
+    if (adapter.install === null) continue;
+    const file = await hooksInstalled(root, adapter, project.config.timeouts.verifyMs);
+    const level = file === null ? "warning" : "ok";
+    count(level);
+    io.stdout(line(level, adapter.label, file ?? "not installed (run rulecast install)"));
+  }
+  io.stdout("\ncache\n");
+  io.stdout(`  home       ${home}
+`);
+  io.stdout(`  project    ${stateDir}
+`);
+  for (const entry of project.config.repos) {
+    if (entry.repo === "local" || entry.rev === void 0) continue;
+    const label = repoLabel(entry.repo, entry.rev);
+    const cached = cachedRepo(home, entry.repo, entry.rev) !== null;
+    io.stdout(`  repos      ${label} \u2014 ${cached ? "cached" : "not fetched (run rulecast install)"}
+`);
+  }
+  io.stdout("\ndry run\n");
+  const dry = await dryRun(project, registry);
+  if (dry.length === 0) io.stdout("  nothing to run\n");
+  for (const result of dry) {
+    count(result.level);
+    io.stdout(line(result.level, result.rule, result.detail));
+  }
+  io.stdout(
+    `
+${errors + warnings === 0 ? "no problems found" : [plural(errors, "error"), plural(warnings, "warning")].join(", ")}
+`
+  );
+  return errors > 0 ? 2 : 0;
+}
+async function dryRun(project, registry) {
+  if (project.rules.length === 0) return [];
+  let files;
+  try {
+    files = await allFiles(project.root);
+  } catch (error) {
+    return [{ rule: "not run", level: "warning", detail: errorMessage(error) }];
+  }
+  const lines = [];
+  for (const rule of project.rules) {
+    if (rule.detector === null) {
+      lines.push({ rule: rule.id, level: "ok", detail: "context only, nothing to run" });
+      continue;
+    }
+    if (rule.detector.kind === "llm") {
+      lines.push({ rule: rule.id, level: "skipped", detail: "llm rules are not dry-run (a model call costs money)" });
+      continue;
+    }
+    const file = files.find((candidate) => rule.matches(candidate));
+    if (file === void 0) {
+      lines.push({ rule: rule.id, level: "warning", detail: "no file in the project matches this rule" });
+      continue;
+    }
+    const timeoutMs = project.config.timeouts.verifyMs;
+    const output = await runDetection({
+      root: project.root,
+      event: "verify",
+      selections: [{ rule, files: [file] }],
+      changes: /* @__PURE__ */ new Map(),
+      read: (name) => readSourceFile(project.root, name),
+      registry,
+      cacheFor: () => memoryCache(),
+      // Only the llm detector reads context, and llm rules never reach here.
+      contextFor: async () => [],
+      settings: { llm: project.config.llm },
+      timeoutMs
+    });
+    const failure = output.errors[0];
+    if (failure) {
+      lines.push({ rule: rule.id, level: "error", detail: failure.message });
+      continue;
+    }
+    if (output.timedOut.length > 0) {
+      lines.push({ rule: rule.id, level: "error", detail: `timed out after ${timeoutMs} ms` });
+      continue;
+    }
+    const matches = output.findings.length;
+    lines.push({
+      rule: rule.id,
+      level: "ok",
+      detail: `${file}, ${matches === 0 ? "no match" : matches === 1 ? "1 match" : `${matches} matches`}`
+    });
+  }
+  return lines;
+}
+
+// src/core/detection/warm.ts
+import path4 from "path";
+var WARM_LOCK = { waitMs: 0, staleMs: 10 * 6e4, retryMs: 20 };
+function warmableKinds(project, registry) {
+  const kinds = /* @__PURE__ */ new Set();
+  for (const rule of project.rules) {
+    const kind = rule.detector?.kind;
+    if (kind !== void 0 && registry.get(kind)?.warm !== void 0) kinds.add(kind);
+  }
+  return [...kinds];
+}
+async function warmDetectors(options) {
+  const { root, stateDir, project, registry } = options;
+  const result = { warmed: [], skipped: [], errors: [] };
+  const kinds = warmableKinds(project, registry).filter((kind) => options.kinds?.includes(kind) ?? true);
+  const signal = AbortSignal.timeout(options.timeoutMs);
+  await Promise.all(
+    kinds.map(async (kind) => {
+      const detector = registry.get(kind);
+      const rules = project.rules.filter((rule) => rule.detector?.kind === kind).map((rule) => ({ id: rule.id, config: rule.detector.config }));
+      try {
+        await withLock(
+          path4.join(stateDir, "warm", kind),
+          () => detector.warm({ rules, cache: diskCache(detectorCacheDir(stateDir, kind)), cwd: root, signal }),
+          WARM_LOCK
+        );
+        result.warmed.push(kind);
+      } catch (error) {
+        if (error instanceof LockTimeoutError) result.skipped.push(kind);
+        else result.errors.push({ kind, message: errorMessage(error) });
+      }
+    })
+  );
+  return result;
+}
+
+// src/commands/hook.ts
+async function hookCommand(args, registry, io) {
+  const name = args[0] ?? "";
+  const adapter = adapterByName(name);
+  if (!adapter) {
+    io.stderr(`rulecast: unknown hook adapter "${name}" (use ${ADAPTERS.map((known) => known.name).join(", ")})
+`);
+    return 0;
+  }
+  let input;
+  try {
+    input = JSON.parse(await io.readStdin());
+  } catch (error) {
+    io.stderr(`rulecast: could not read hook input: ${errorMessage(error)}
+`);
+    return 0;
+  }
+  const parsed = adapter.parse(input);
+  if (!parsed || !parsed.event && !parsed.warmup) return 0;
+  const root = findRoot(parsed.cwd);
+  if (!hasProject(root)) return 0;
+  const home = cacheHome(io.env);
+  const stateDir = ensureProjectState(home, root);
+  const log = debugLogger(stateDir);
+  try {
+    const compileProject = () => compile({ root, registry, repos: cachedRepos(home) });
+    if (parsed.warmup) {
+      const kinds = warmableKinds(await compileProject(), registry);
+      if (kinds.length > 0) io.startWarm(root, kinds);
+    }
+    if (parsed.event) {
+      await handleEvent({
+        root,
+        stateDir,
+        cwd: parsed.cwd,
+        event: parsed.event,
+        adapter,
+        registry,
+        io,
+        log,
+        compileProject
+      });
+    }
+  } catch (error) {
+    log(`hook ${adapter.name}: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+    io.stderr(`rulecast: ${errorMessage(error)}
+`);
+  }
+  return 0;
+}
+async function handleEvent(context) {
+  const { root, stateDir, cwd, event, adapter, registry, io, log } = context;
+  const files = event.files.map((file) => toProjectPath(root, cwd, file)).filter((file) => file !== null);
+  if ((event.kind === "touch" || event.kind === "edit" || event.kind === "guard") && files.length === 0) return;
+  const projectEvent = { ...event, files, cwd: root };
+  const project = await context.compileProject();
+  const result = await runPipeline({
+    project,
+    stateDir,
+    event: projectEvent,
+    registry,
+    maxContextChars: adapter.maxContextChars,
+    restoredFiles: adapter.restoredFiles,
+    stopGate: projectEvent.kind === "verify",
+    log
+  });
+  const output = adapter.format(result.delivery, projectEvent, { maxMatchesPerRule: project.config.maxMatchesPerRule });
+  if (output.stdout !== "") io.stdout(output.stdout);
+  const missed = result.deadlineMissed.filter((kind) => registry.get(kind)?.warm !== void 0);
+  if (missed.length > 0) io.startWarm(root, missed);
+}
+
+// src/commands/init.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import path6 from "path";
+import { parseArgs as parseArgs4 } from "util";
+import { parse } from "yaml";
+
+// src/init/detect.ts
+import { statSync } from "fs";
+import path5 from "path";
+var KNOWN_AGENTS = [
+  { name: "cursor", label: "Cursor", markers: [".cursor/"] },
+  { name: "codex", label: "Codex", markers: [".codex/"] }
+];
+var IMPORTS_AGENTS = /^[ \t]*@(\.\/)?AGENTS\.md[ \t]*$/m;
+var NOT_A_DOC = /^(readme|changelog|license)/i;
+var AGENT_DOCS = /* @__PURE__ */ new Set(["AGENTS.md", "CLAUDE.md"]);
+var basename = (file) => path5.posix.basename(file);
+var segments = (file) => file.split("/");
+var inNodeModules = (file) => segments(file).includes("node_modules");
+var inDotDir = (file) => segments(file).slice(0, -1).some((segment) => segment.startsWith("."));
+var byDepth = (a, b) => segments(a).length - segments(b).length || (a < b ? -1 : a > b ? 1 : 0);
+function usesReact(text) {
+  if (text === null) return false;
+  try {
+    const manifest = JSON.parse(text);
+    return ["dependencies", "devDependencies", "peerDependencies"].some((key) => {
+      const dependencies = manifest[key];
+      return typeof dependencies === "object" && dependencies !== null && "react" in dependencies;
+    });
+  } catch {
+    return false;
+  }
+}
+async function detectStack(files, read) {
+  const tags = /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    for (const tag of tagsOf(file)) tags.add(tag);
+    names.add(basename(file));
+  }
+  const stack = [];
+  const pythonMarker = names.has("pyproject.toml") || [...names].some((name) => /^requirements.*\.txt$/.test(name));
+  if (tags.has("python") || pythonMarker) stack.push("python");
+  if (tags.has("ts") || tags.has("tsx")) stack.push("typescript");
+  if (tags.has("javascript") || tags.has("jsx")) stack.push("javascript");
+  for (const file of files.filter((candidate) => basename(candidate) === "package.json")) {
+    if (usesReact(await read(file))) {
+      stack.push("react");
+      break;
+    }
+  }
+  return stack;
+}
+async function detectDocs(files, read) {
+  const present = new Set(files);
+  const named = (name) => files.filter((file) => basename(file) === name).sort(byDepth);
+  const importedBy = /* @__PURE__ */ new Map();
+  const standalone = [];
+  for (const file of named("CLAUDE.md")) {
+    const sibling = path5.posix.join(path5.posix.dirname(file), "AGENTS.md");
+    const text = await read(file);
+    if (text !== null && present.has(sibling) && IMPORTS_AGENTS.test(text)) importedBy.set(sibling, file);
+    else standalone.push(file);
+  }
+  const others = files.filter((file) => {
+    const tags = tagsOf(file);
+    const name = basename(file);
+    return (tags.has("markdown") || tags.has("mdx")) && !AGENT_DOCS.has(name) && !NOT_A_DOC.test(name) && !inDotDir(file);
+  }).sort();
+  const docs = [];
+  const add = async (file, by) => {
+    const text = await read(file);
+    if (text !== null) docs.push({ file, headings: scanHeadings(text), importedBy: by });
+  };
+  for (const file of named("AGENTS.md")) await add(file, importedBy.get(file) ?? null);
+  for (const file of standalone) await add(file, null);
+  for (const file of others) await add(file, null);
+  return docs;
+}
+function detectAgents(input) {
+  const agents = [];
+  for (const adapter of input.adapters) {
+    const marker = adapter.install?.markers.find((candidate) => input.exists(candidate));
+    if (marker !== void 0) agents.push({ name: adapter.name, label: adapter.label, adapter, marker });
+  }
+  for (const known of KNOWN_AGENTS) {
+    const marker = known.markers.find((candidate) => input.exists(candidate));
+    if (marker !== void 0) agents.push({ name: known.name, label: known.label, adapter: null, marker });
+  }
+  return agents;
+}
+function markerExists(root) {
+  return (marker) => {
+    try {
+      const stat = statSync(path5.join(root, marker));
+      return !marker.endsWith("/") || stat.isDirectory();
+    } catch {
+      return false;
+    }
+  };
+}
+async function detectProject(input) {
+  const files = input.files.filter((file) => !inNodeModules(file));
+  const docs = await detectDocs(files, input.read);
+  const primary = docs.find((doc) => basename(doc.file) === "AGENTS.md") ?? docs.find((doc) => basename(doc.file) === "CLAUDE.md");
+  return {
+    stack: await detectStack(files, input.read),
+    docs,
+    primaryDoc: primary?.file ?? null,
+    agents: detectAgents(input)
+  };
+}
+function detectionSummary(detection) {
+  const parts = [...detection.stack];
+  for (const doc of detection.docs) {
+    if (!AGENT_DOCS.has(basename(doc.file))) continue;
+    parts.push(doc.importedBy === null ? doc.file : `${doc.file} (imported by ${doc.importedBy})`);
+  }
+  const others = detection.docs.filter((doc) => !AGENT_DOCS.has(basename(doc.file))).length;
+  if (others > 0) parts.push(`${others} other ${others === 1 ? "doc" : "docs"}`);
+  for (const agent of detection.agents) {
+    parts.push(`${agent.label} (${agent.marker}${agent.adapter === null ? ", not supported yet" : ""})`);
+  }
+  return parts.length === 0 ? "nothing yet" : parts.join(" \xB7 ");
+}
+function docChoices(doc) {
+  const choices = [{ value: `@${doc.file}`, label: doc.file }];
+  const trail = [];
+  for (const heading of doc.headings) {
+    while (trail.length > 0 && trail.at(-1).level >= heading.level) trail.pop();
+    trail.push(heading);
+    if (heading.slug === "") continue;
+    choices.push({
+      value: `@${doc.file}#${heading.slug}`,
+      label: [doc.file, ...trail.map((entry) => entry.text)].join(" \u203A ")
+    });
+  }
+  return choices;
+}
+
+// src/init/draft-prompt.ts
+function draftPrompt(tag, doc) {
+  return [
+    `Read https://raw.githubusercontent.com/syv-ai/rulecast/${tag}/agents/DRAFT-RULES.md`,
+    `and follow it to draft rulecast rules for this project from ${doc ?? "the project's docs"}.`
+  ].join("\n");
+}
+
+// src/init/config-text.ts
+import { isMap as isMap2, isScalar as isScalar2, isSeq as isSeq2, parseDocument as parseDocument2 } from "yaml";
+var ConfigTextError = class extends Error {
+};
+var HEADER = [
+  "# rulecast config: https://github.com/syv-ai/rulecast",
+  "# Rules from rule repos are pinned by rev; add your own rules under repo: local."
+];
+var scalar = (value) => /^[A-Za-z0-9_./:@~+-]+$/.test(value) ? value : JSON.stringify(value);
+function ruleLines(rule) {
+  const lines = [`- id: ${rule.id}`];
+  if (rule.context !== null) lines.push("  context:", ...rule.context.map((ref) => `    - ${JSON.stringify(ref)}`));
+  return lines;
+}
+function repoLines(catalog, rules) {
+  return [
+    `- repo: ${scalar(catalog.url)}`,
+    `  rev: ${scalar(catalog.rev)}`,
+    "  rules:",
+    ...rules.flatMap(ruleLines).map((line2) => `    ${line2}`)
+  ];
+}
+var indent = (lines, column) => lines.map((line2) => `${" ".repeat(column)}${line2}
+`).join("");
+function newConfigText(catalog, rules) {
+  const lines = [...HEADER, "repos:"];
+  if (catalog !== null && rules.length > 0) lines.push(...repoLines(catalog, rules).map((line2) => `  ${line2}`));
+  lines.push("  - repo: local", "    rules: []");
+  return `${lines.join("\n")}
+`;
+}
+function columnOf(text, offset) {
+  return offset - (text.lastIndexOf("\n", offset - 1) + 1);
+}
+function lineEndAfter(text, offset) {
+  const newline = text.indexOf("\n", offset);
+  return newline === -1 ? text.length : newline + 1;
+}
+function appendToSeq(text, seq, keyNode, items) {
+  const [start, valueEnd] = seq.range;
+  if (seq.flow) {
+    const at = lineEndAfter(text, valueEnd);
+    const rest = text.slice(valueEnd, at).trim();
+    if (seq.items.length > 0 || rest !== "" && !rest.startsWith("#")) {
+      throw new ConfigTextError("write repos and their rules in block style so rulecast init can add to them");
+    }
+    let from = start;
+    while (from > 0 && (text[from - 1] === " " || text[from - 1] === "	")) from--;
+    const column2 = columnOf(text, keyNode.range[0]) + 2;
+    return { start: from, end: at, insert: `${rest === "" ? "" : ` ${rest}`}
+${indent(items, column2)}` };
+  }
+  const column = columnOf(text, start);
+  const prefix = valueEnd === 0 || text[valueEnd - 1] === "\n" ? "" : "\n";
+  return { start: valueEnd, end: valueEnd, insert: `${prefix}${indent(items, column)}` };
+}
+function pairKey(map, key) {
+  const pair = map.items.find((item) => isScalar2(item.key) && item.key.value === key);
+  return pair && isScalar2(pair.key) ? pair.key : null;
+}
+function addCatalogRules(text, catalog, rules) {
+  const doc = parseDocument2(text, { keepSourceTokens: true });
+  if (doc.errors.length > 0) throw new ConfigTextError(doc.errors[0].message);
+  const root = doc.contents;
+  if (!isMap2(root)) throw new ConfigTextError("the config must be a mapping");
+  const reposKey = pairKey(root, "repos");
+  const repos = root.get("repos", true);
+  if (reposKey === null || !isSeq2(repos)) throw new ConfigTextError("the config has no repos list");
+  const entry = repos.items.find((item) => isMap2(item) && item.get("repo") === catalog.url);
+  let edit;
+  if (entry) {
+    const listed = entry.get("rules", true);
+    const rulesKey = pairKey(entry, "rules");
+    if (!isSeq2(listed) || rulesKey === null) throw new ConfigTextError(`${catalog.url} has no rules list`);
+    const present = new Set(listed.items.map((item) => isMap2(item) ? item.get("id") : void 0));
+    const added = rules.filter((rule) => !present.has(rule.id));
+    if (added.length === 0) return text;
+    edit = appendToSeq(text, listed, rulesKey, added.flatMap(ruleLines));
+  } else {
+    if (rules.length === 0) return text;
+    edit = appendToSeq(text, repos, reposKey, repoLines(catalog, rules));
+  }
+  const updated = text.slice(0, edit.start) + edit.insert + text.slice(edit.end);
+  const check = parseDocument2(updated);
+  if (check.errors.length > 0) throw new ConfigTextError(`could not update the config: ${check.errors[0].message}`);
+  return updated;
+}
+
+// src/init/plan.ts
+var PlanError = class extends Error {
+};
+var plural2 = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+function parseSettings(text, file) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new PlanError(`${file}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function planConfig(selections, configText) {
+  const { catalog, rules } = selections;
+  const from = catalog === null ? "" : ` from ${repoLabel(catalog.url, catalog.rev)}`;
+  if (configText === null) {
+    const summary = rules.length === 0 ? "new, no rules yet" : `new, ${plural2(rules.length, "rule")}${from}`;
+    return { file: CONFIG_FILE, content: newConfigText(catalog, rules), created: true, summary, commit: true };
+  }
+  if (catalog === null || rules.length === 0) return null;
+  const content = addCatalogRules(configText, catalog, rules);
+  if (content === configText) return null;
+  return {
+    file: CONFIG_FILE,
+    content,
+    created: false,
+    summary: `+${plural2(rules.length, "rule")}${from}`,
+    commit: true
+  };
+}
+async function planAgent(choice, context) {
+  const install = choice.adapter.install;
+  if (install === null) return null;
+  const command = install.command(context.local);
+  const merge = (settings, file) => {
+    try {
+      return install.merge(settings, command, context.verifyMs);
+    } catch (error) {
+      throw new PlanError(`${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+  for (const { file } of install.scopes) {
+    const text2 = await context.readText(file);
+    if (text2 !== null && merge(parseSettings(text2, file), file).added.length === 0) return null;
+  }
+  const target = install.scopes.find((entry) => entry.scope === choice.scope);
+  if (target === void 0) throw new PlanError(`${choice.adapter.label} has no ${choice.scope} settings`);
+  const text = await context.readText(target.file);
+  const merged = merge(text === null ? {} : parseSettings(text, target.file), target.file);
+  return {
+    file: target.file,
+    content: `${JSON.stringify(merged.settings, null, 2)}
+`,
+    created: text === null,
+    summary: `+${plural2(merged.added.length, "hook")} (${choice.adapter.label})`,
+    commit: choice.scope === "shared"
+  };
+}
+async function planInit(selections, context) {
+  const changes = [];
+  const config = planConfig(selections, context.configText);
+  if (config !== null) changes.push(config);
+  for (const choice of selections.agents) {
+    const change = await planAgent(choice, context);
+    if (change !== null) changes.push(change);
+  }
+  return changes;
+}
+function reviewText(changes) {
+  const width = Math.max(...changes.map((change) => change.file.length));
+  return changes.map((change) => `${change.file.padEnd(width)}  ${change.summary}`).join("\n");
+}
+
+// src/commands/init.ts
+var DEFAULT_CATALOG = "https://github.com/syv-ai/rulecast";
+var SCOPES = ["shared", "personal"];
+var installable = () => ADAPTERS.filter((adapter) => adapter.install !== null);
+function parseFlags(args) {
+  const { values } = parseArgs4({
+    args,
+    options: {
+      rules: { type: "string" },
+      "no-rules": { type: "boolean", default: false },
+      agent: { type: "string", multiple: true },
+      scope: { type: "string" },
+      yes: { type: "boolean", default: false }
+    }
+  });
+  if (values.rules !== void 0 && values["no-rules"]) throw new UsageError("use --rules or --no-rules, not both");
+  const scope = values.scope ?? null;
+  if (scope !== null && !SCOPES.includes(scope)) {
+    throw new UsageError(`unknown scope "${scope}" (use shared or personal)`);
+  }
+  const agents = (values.agent ?? []).map((name) => {
+    const adapter = adapterByName(name);
+    if (!adapter?.install) {
+      const names = installable().map((each) => each.name);
+      throw new UsageError(`unknown agent "${name}" (use ${names.join(", ")})`);
+    }
+    return adapter;
+  });
+  const rules = values.rules === void 0 ? null : values.rules.split(",").map((id) => id.trim()).filter(Boolean);
+  return { rules, noRules: values["no-rules"], agents, scope, yes: values.yes };
+}
+function projectRoot(cwd) {
+  const found = findRoot(cwd);
+  if (hasProject(found)) return found;
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return cwd;
+  }
+}
+async function readConfig(root) {
+  const text = await readSourceFile(root, CONFIG_FILE);
+  if (text === null) return { text: null, config: null };
+  let data;
+  try {
+    data = parse(text);
+  } catch (error) {
+    throw new Error(`${CONFIG_FILE}: ${errorMessage(error)} (fix it, then run rulecast init again)`);
+  }
+  const parsed = parseConfig(data ?? {});
+  if (!parsed.ok) throw new Error(`${parsed.message} (fix it, then run rulecast init again)`);
+  return { text, config: parsed.value };
+}
+async function loadCatalog(url, rev, home, registry) {
+  try {
+    let pinned = rev;
+    if (pinned === void 0) {
+      const tag = latestTag(await remoteTags(url));
+      if (tag === null) return `${url} has no version tags`;
+      pinned = tag.name;
+    }
+    const dir = await ensureRepo(home, url, pinned);
+    const { rules } = await compileManifest(dir, registry);
+    return { url, rev: pinned, label: repoLabel(url, pinned), rules };
+  } catch (error) {
+    return errorMessage(error);
+  }
+}
+var idOf = (entry) => {
+  const id = entry?.id;
+  return typeof id === "string" ? id : null;
+};
+var groupOf = (id) => id.includes("/") ? id.slice(0, id.indexOf("/")) : "general";
+async function chooseRules(catalog, installed, files, flags, ui) {
+  const available = catalog.rules.filter((rule) => !installed.has(rule.id));
+  if (flags.noRules) return [];
+  if (flags.rules !== null) {
+    const known = new Set(catalog.rules.map((rule) => rule.id));
+    const unknown = flags.rules.find((id) => !known.has(id));
+    if (unknown !== void 0) throw new UsageError(`"${unknown}" is not a rule in ${catalog.label}`);
+    return available.filter((rule) => flags.rules.includes(rule.id));
+  }
+  const preselected = available.filter((rule) => rule.detector?.kind !== "llm" && files.some((file) => rule.matches(file))).map((rule) => rule.id);
+  if (ui.prompter === null) return available.filter((rule) => preselected.includes(rule.id));
+  if (available.length === 0) {
+    ui.say(`Every rule from ${catalog.label} is already configured.`, "Rules");
+    return [];
+  }
+  const groups = {};
+  for (const rule of catalog.rules) {
+    const group = groupOf(rule.id);
+    const done = installed.has(rule.id);
+    const choices = groups[group] ?? [];
+    choices.push({
+      value: rule.id,
+      label: group === "general" ? rule.id : rule.id.slice(group.length + 1),
+      hint: done ? "installed" : hintFor(rule),
+      disabled: done
+    });
+    groups[group] = choices;
+  }
+  const chosen = await ui.prompter.groupMultiselect({
+    message: `Rules from ${catalog.label}`,
+    groups,
+    initialValues: preselected
+  });
+  return available.filter((rule) => chosen.includes(rule.id));
+}
+function hintFor(rule) {
+  const description = rule.description ?? rule.name;
+  if (rule.detector?.kind !== "llm") return description;
+  const model = rule.detector.config.model ?? "a model";
+  return `llm \xB7 ${model} \xB7 sends file contents to your provider \u2014 ${description}`;
+}
+async function chooseConventions(rules, detection, ui) {
+  const choices = detection.docs.flatMap(docChoices);
+  const selections = [];
+  for (const rule of rules) {
+    if (ui.prompter === null || rule.context.length === 0 || choices.length === 0) {
+      selections.push({ id: rule.id, context: null });
+      continue;
+    }
+    const keep = {
+      value: "",
+      label: "keep the package's doc",
+      hint: rule.context.map((spec) => spec.ref).join(", ")
+    };
+    const answer = await ui.prompter.select({
+      message: `Conventions for ${rule.id}`,
+      choices: [keep, ...choices],
+      initialValue: ""
+    });
+    selections.push({ id: rule.id, context: answer === "" ? null : [answer] });
+  }
+  return selections;
+}
+async function chooseAgents(detection, flags, ui) {
+  const detected = detection.agents.filter((agent) => agent.adapter !== null).map((agent) => agent.name);
+  let chosen;
+  if (flags.agents.length > 0) chosen = flags.agents;
+  else if (ui.prompter === null) chosen = installable().filter((adapter) => detected.includes(adapter.name));
+  else {
+    const choices = installable().map((adapter) => ({
+      value: adapter.name,
+      label: adapter.label,
+      hint: detected.includes(adapter.name) ? "detected" : void 0
+    }));
+    for (const agent of detection.agents) {
+      if (agent.adapter === null) {
+        choices.push({
+          value: `unsupported:${agent.name}`,
+          label: agent.label,
+          hint: "not supported yet",
+          disabled: true
+        });
+      }
+    }
+    const names = await ui.prompter.multiselect({ message: "Install hooks for", choices, initialValues: detected });
+    chosen = installable().filter((adapter) => names.includes(adapter.name));
+  }
+  if (chosen.length === 0) {
+    ui.say("No agent hooks will be installed. Add them later with rulecast install --agent <name>.", "Agents");
+  }
+  const agents = [];
+  for (const adapter of chosen) {
+    let scope = flags.scope ?? "shared";
+    if (flags.scope === null && ui.prompter !== null) {
+      scope = await ui.prompter.select({
+        message: `${adapter.label} hooks in`,
+        choices: adapter.install.scopes.map((entry) => ({
+          value: entry.scope,
+          label: `${entry.scope} (${entry.file})`
+        })),
+        initialValue: "shared"
+      });
+    }
+    agents.push({ adapter, scope });
+  }
+  return agents;
+}
+async function write(root, changes) {
+  for (const change of changes) {
+    const file = path6.join(root, change.file);
+    await mkdir2(path6.dirname(file), { recursive: true });
+    await writeFile3(file, change.content);
+  }
+}
+async function validate(root, home, registry, ui) {
+  const project = await compile({ root, registry, repos: fetchingRepos(home) });
+  const errors = project.diagnostics.filter((diagnostic) => diagnostic.level === "error");
+  const lines = project.diagnostics.map(
+    (diagnostic) => `${diagnostic.level === "warning" ? "warning: " : ""}${diagnostic.source}${diagnostic.rule ? ` (${diagnostic.rule})` : ""}: ${diagnostic.message}`
+  );
+  if (errors.length === 0) {
+    const count = project.rules.length;
+    lines.push(`rulecast validate: ${count} ${count === 1 ? "rule" : "rules"} valid`);
+  }
+  ui.say(lines.join("\n"), "Validate");
+  return errors.length;
+}
+async function run(root, flags, registry, io, ui) {
+  const home = cacheHome(io.env);
+  if (ui.prompter !== null) ui.prompter.intro(`rulecast init \xB7 ${root}`);
+  else io.stdout(`rulecast init \xB7 ${root}
+
+`);
+  const { text: configText, config } = await readConfig(root);
+  const files = await allFiles(root);
+  const detection = await detectProject({
+    files,
+    read: (file) => readSourceFile(root, file),
+    exists: markerExists(root),
+    adapters: ADAPTERS
+  });
+  ui.say(detectionSummary(detection), "Detected");
+  const url = io.env.RULECAST_CATALOG || DEFAULT_CATALOG;
+  const configured = config?.repos.find((repo) => repo.repo === url);
+  const loaded = await loadCatalog(url, configured?.rev, home, registry);
+  const catalog = typeof loaded === "string" ? null : loaded;
+  if (typeof loaded === "string") ui.say(`${loaded}. Continuing without catalog rules.`, "Catalog unavailable");
+  const installed = new Set((configured?.rules ?? []).map(idOf).filter((id) => id !== null));
+  const rules = catalog === null ? [] : await chooseRules(catalog, installed, files, flags, ui);
+  const selections = await chooseConventions(rules, detection, ui);
+  const agents = await chooseAgents(detection, flags, ui);
+  const changes = await planInit(
+    { catalog: catalog === null ? null : { url: catalog.url, rev: catalog.rev }, rules: selections, agents },
+    {
+      configText,
+      verifyMs: (config ?? defaultConfig()).timeouts.verifyMs,
+      local: existsSync4(path6.join(root, "node_modules", ".bin", "rulecast")),
+      readText: (file) => readSourceFile(root, file)
+    }
+  );
+  if (changes.length === 0) ui.say("Nothing to change.", "Review");
+  else {
+    ui.say(reviewText(changes), "Review");
+    if (ui.prompter !== null) {
+      if (!await ui.prompter.confirm({ message: "Write?", initialValue: true })) {
+        ui.prompter.outro("Nothing written.");
+        return 0;
+      }
+    } else if (!flags.yes) {
+      io.stdout("Nothing written. Rerun with --yes to write these changes, or run rulecast init in a terminal.\n");
+      return 2;
+    }
+    await write(root, changes);
+  }
+  const errors = await validate(root, home, registry, ui);
+  const prompt = draftPrompt(catalog?.rev ?? `v${VERSION}`, detection.primaryDoc);
+  const toCommit = changes.filter((change) => change.commit).map((change) => change.file);
+  const closing = toCommit.length === 0 ? "Done." : `Commit ${toCommit.join(" and ")}.`;
+  if (ui.prompter !== null) {
+    ui.say(prompt, "Draft rules for your own conventions. Paste this into your coding agent:");
+    if (await ui.prompter.confirm({ message: "Copy to clipboard?", initialValue: true })) {
+      ui.say(await io.copyToClipboard(prompt) ? "Copied." : "No clipboard command found: copy it from above.");
+    }
+    ui.prompter.outro(closing);
+  } else {
+    ui.say(prompt, "Draft rules for your own conventions. Paste this into your coding agent:");
+    io.stdout(`${closing}
+`);
+  }
+  return errors > 0 ? 2 : 0;
+}
+async function initCommand(args, registry, io) {
+  const flags = parseFlags(args);
+  const root = projectRoot(io.cwd);
+  const prompter = io.interactive && !flags.yes ? await io.prompter() : null;
+  const ui = {
+    prompter,
+    say: (message, title) => {
+      if (prompter !== null) prompter.note(message, title);
+      else io.stdout(`${title === void 0 ? "" : `${title}
+`}${message}
+
+`);
+    }
+  };
+  try {
+    return await run(root, flags, registry, io, ui);
+  } catch (error) {
+    if (!(error instanceof Cancelled)) throw error;
+    io.stderr("rulecast: init cancelled\n");
+    return 130;
+  }
+}
+
+// src/commands/run.ts
+import { parseArgs as parseArgs5 } from "util";
+
+// src/adapters/cli/format.ts
+var CLI_FORMATS = ["terminal", "agent", "json", "sarif"];
+var plural3 = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+function terminal(delivery, options) {
+  const out = [];
+  const shown = /* @__PURE__ */ new Map();
+  const hidden = /* @__PURE__ */ new Map();
+  for (const finding of delivery.findings) {
+    const count = shown.get(finding.rule) ?? 0;
+    if (count >= options.maxMatchesPerRule) {
+      hidden.set(finding.rule, [...hidden.get(finding.rule) ?? [], finding]);
+      continue;
+    }
+    shown.set(finding.rule, count + 1);
+    const repeat = finding.count > 1 ? ` (\xD7${finding.count})` : "";
+    out.push(
+      `${finding.file}:${finding.line}:${finding.column}  ${finding.severity.padEnd(7)}  ${finding.rule}  ${finding.message.replace(/\s*\n\s*/g, " ")}${repeat}`
+    );
+  }
+  for (const [rule, rest] of hidden) out.push(`\u2026and ${rest.length} more for ${rule}`);
+  if (out.length > 0) out.push("");
+  for (const summary of delivery.preexistingSummary) {
+    out.push(`pre-existing (not blocking): ${summary.rule} \xD7${summary.count} in ${summary.file}`);
+  }
+  if (delivery.references.length > 0) {
+    out.push(`conventions: ${delivery.references.map((reference) => reference.ref).join(", ")}`);
+  }
+  if (delivery.preexistingSummary.length > 0 || delivery.references.length > 0) out.push("");
+  if (delivery.warnings.length > 0) {
+    out.push("warnings:", ...delivery.warnings.map((warning) => `  - ${warning}`), "");
+  }
+  const errors = delivery.findings.filter((finding) => finding.severity === "error").length;
+  const warningsCount = delivery.findings.length - errors;
+  out.push(
+    delivery.findings.length === 0 ? "no findings" : `${plural3(errors, "error")}, ${plural3(warningsCount, "warning")}`
+  );
+  return out.join("\n");
+}
+function sarif(delivery) {
+  const rules = [...new Set(delivery.findings.map((finding) => finding.rule))].map((id) => ({ id }));
+  return JSON.stringify(
+    {
+      $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+      version: "2.1.0",
+      runs: [
+        {
+          tool: { driver: { name: "rulecast", rules } },
+          results: delivery.findings.map((finding) => ({
+            ruleId: finding.rule,
+            level: finding.severity,
+            message: { text: finding.message },
+            locations: [
+              {
+                physicalLocation: {
+                  artifactLocation: { uri: finding.file },
+                  region: { startLine: finding.line, startColumn: finding.column }
+                }
+              }
+            ]
+          }))
+        }
+      ]
+    },
+    null,
+    2
+  );
+}
+function formatDelivery(delivery, format, options) {
+  switch (format) {
+    case "terminal":
+      return terminal(delivery, options);
+    case "agent":
+      return renderAgentText(delivery, options);
+    case "json":
+      return JSON.stringify(delivery, null, 2);
+    case "sarif":
+      return sarif(delivery);
+  }
+}
+function exitCodeFor(delivery, failed) {
+  if (failed) return 2;
+  return delivery.findings.some((finding) => finding.severity === "error") ? 1 : 0;
+}
+
+// src/commands/run.ts
+function parseRunArgs(args) {
+  const { values, tokens } = parseArgs5({
+    args,
+    allowPositionals: true,
+    tokens: true,
+    options: {
+      files: { type: "boolean", default: false },
+      "all-files": { type: "boolean", default: false },
+      "from-ref": { type: "string" },
+      "to-ref": { type: "string" },
+      format: { type: "string", default: "terminal" },
+      session: { type: "string" },
+      "no-llm": { type: "boolean", default: false },
+      ref: { type: "string" }
+    }
+  });
+  const format = values.format;
+  if (!CLI_FORMATS.includes(format)) {
+    throw new UsageError(`unknown format "${values.format}" (use ${CLI_FORMATS.join(", ")})`);
+  }
+  let filesAt = Number.POSITIVE_INFINITY;
+  for (const token of tokens) {
+    if (token.kind === "option" && token.name === "files") filesAt = Math.min(filesAt, token.index);
+  }
+  const leading = [];
+  const files = [];
+  for (const token of tokens) {
+    if (token.kind !== "positional") continue;
+    if (token.index > filesAt) files.push(token.value);
+    else leading.push(token.value);
+  }
+  const fromRef = values["from-ref"] ?? null;
+  const toRef = values["to-ref"] ?? null;
+  if (values.files && files.length === 0) throw new UsageError("--files needs at least one file");
+  if (values.files && values["all-files"]) throw new UsageError("--all-files and --files cannot be combined");
+  if (toRef !== null && fromRef === null) throw new UsageError("--to-ref needs --from-ref");
+  if (fromRef !== null && (values.files || values["all-files"])) {
+    throw new UsageError("--from-ref cannot be combined with --all-files or --files");
+  }
+  return {
+    leading,
+    files: values.files ? files : null,
+    allFiles: values["all-files"],
+    fromRef,
+    toRef,
+    format,
+    session: values.session ?? null,
+    noLlm: values["no-llm"],
+    ref: values.ref ?? null
+  };
+}
+async function selectFiles(root, cwd, run2) {
+  if (run2.files !== null) {
+    const files = run2.files.map((file) => toProjectPath(root, cwd, file)).filter((file) => file !== null);
+    return { files, baseCommit: null };
+  }
+  if (run2.fromRef !== null) {
+    const base = await mergeBase(root, run2.fromRef, run2.toRef ?? "HEAD");
+    const files = run2.toRef === null ? await changedFilesSince(root, base) : await changedFilesBetween(root, base, run2.toRef);
+    return { files, baseCommit: base };
+  }
+  if (run2.allFiles) return { files: await allFiles(root), baseCommit: null };
+  if (run2.session !== null) return { files: [], baseCommit: null };
+  return { files: await stagedFiles(root), baseCommit: null };
+}
+async function executeRun({ project, ruleId, run: run2, registry, io }) {
+  const root = project.root;
+  if (ruleId !== null && !project.rules.some((rule) => rule.id === ruleId)) {
+    throw new UsageError(`no rule "${ruleId}" (see rulecast validate)`);
+  }
+  const selected = await selectFiles(root, io.cwd, run2);
+  const result = await runPipeline({
+    project,
+    stateDir: ensureProjectState(cacheHome(io.env), root),
+    event: {
+      kind: "verify",
+      files: selected.files,
+      baseCommit: selected.baseCommit ?? void 0,
+      session: run2.session === null ? void 0 : { id: run2.session },
+      cwd: root
+    },
+    registry,
+    maxContextChars: null,
+    skipDetectorKinds: run2.noLlm ? /* @__PURE__ */ new Set(["llm"]) : void 0,
+    onlyRules: ruleId === null ? void 0 : /* @__PURE__ */ new Set([ruleId])
+  });
+  const text = formatDelivery(result.delivery, run2.format, { maxMatchesPerRule: project.config.maxMatchesPerRule });
+  if (text) io.stdout(`${text}
+`);
+  return exitCodeFor(result.delivery, result.failed);
+}
+async function runCommand(root, args, registry, io) {
+  const run2 = parseRunArgs(args);
+  if (run2.ref !== null) throw new UsageError("--ref only applies to try-repo");
+  if (run2.leading.length > 1) throw new UsageError(`unexpected arguments: ${run2.leading.slice(1).join(" ")}`);
+  if (!hasProject(root)) throw new Error(`no ${CONFIG_FILE} in ${io.cwd} or its parents`);
+  const project = await compile({ root, registry, repos: fetchingRepos(cacheHome(io.env)) });
+  return executeRun({ project, ruleId: run2.leading[0] ?? null, run: run2, registry, io });
+}
+
+// src/commands/try-repo.ts
+import { existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { mkdtemp, rm as rm2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import path7 from "path";
+var isDirectory = (file) => existsSync5(file) && statSync2(file).isDirectory();
+var isGitRepo = (dir) => existsSync5(path7.join(dir, ".git")) || existsSync5(path7.join(dir, "HEAD"));
+async function baseConfigData(root) {
+  if (!hasProject(root)) return {};
+  const data = await readConfigData(root);
+  if (!data.ok) throw new Error(data.message);
+  return typeof data.value === "object" && data.value !== null && !Array.isArray(data.value) ? data.value : {};
+}
+async function tryRepoCommand(root, args, registry, io) {
+  const run2 = parseRunArgs(args);
+  const [repo, ruleId, ...extra] = run2.leading;
+  if (repo === void 0) throw new UsageError("try-repo needs a repository path or URL");
+  if (extra.length > 0) throw new UsageError(`unexpected arguments: ${extra.join(" ")}`);
+  const local = path7.resolve(io.cwd, repo);
+  const directory = isDirectory(local);
+  if (directory && run2.ref !== null && !isGitRepo(local)) throw new UsageError("--ref only applies to URLs");
+  const fromDirectory = directory && run2.ref === null;
+  const rev = fromDirectory ? "working-tree" : run2.ref ?? "HEAD";
+  const temp = fromDirectory ? null : await mkdtemp(path7.join(tmpdir2(), "rulecast-try-repo-"));
+  try {
+    const dir = temp ?? local;
+    if (temp !== null) await fetchCheckout(directory ? local : repo, rev, temp);
+    const label = fromDirectory ? `${path7.basename(local)}@${rev}` : repoLabel(repo, rev);
+    const manifest = await readManifest(dir);
+    if (!manifest.ok) throw new Error(`${label}: ${manifest.message}`);
+    const ids = manifest.value.flatMap((rule) => {
+      const id = rule?.id;
+      return typeof id === "string" ? [id] : [];
+    });
+    if (ruleId !== void 0 && !ids.includes(ruleId)) throw new UsageError(`no rule "${ruleId}" in ${label}`);
+    const configData = {
+      ...await baseConfigData(root),
+      repos: [{ repo, rev, rules: (ruleId === void 0 ? ids : [ruleId]).map((id) => ({ id })) }]
+    };
+    const project = await compile({ root, registry, repos: fixedRepo(dir, label), configData });
+    return await executeRun({ project, ruleId: null, run: run2, registry, io });
+  } finally {
+    if (temp !== null) await rm2(temp, { recursive: true, force: true });
+  }
+}
+
+// src/commands/validate.ts
+import { existsSync as existsSync6 } from "fs";
+import path8 from "path";
+function formatDiagnostic(diagnostic) {
+  return `${diagnostic.level === "warning" ? "warning: " : ""}${diagnosticText(diagnostic)}`;
+}
+async function validateCommand(root, args, registry, io) {
+  const targets = args.length > 0 ? args.map((file) => ({ shown: file, full: path8.resolve(io.cwd, file) })) : [CONFIG_FILE, MANIFEST_FILE].filter((name) => existsSync6(path8.join(root, name))).map((name) => ({ shown: name, full: path8.join(root, name) }));
+  if (targets.length === 0) throw new Error(`nothing to validate: no ${CONFIG_FILE} or ${MANIFEST_FILE}`);
+  for (const { shown, full } of targets) {
+    const name = path8.basename(full);
+    if (name !== CONFIG_FILE && name !== MANIFEST_FILE) {
+      throw new UsageError(`${shown}: not a ${CONFIG_FILE} or ${MANIFEST_FILE}`);
+    }
+  }
+  let failed = false;
+  for (const { shown, full } of targets) {
+    const dir = path8.dirname(full);
+    const result = path8.basename(full) === CONFIG_FILE ? await compile({ root: dir, registry, repos: fetchingRepos(cacheHome(io.env)) }) : await compileManifest(dir, registry);
+    for (const diagnostic of result.diagnostics) io.stdout(`${shown}: ${formatDiagnostic(diagnostic)}
+`);
+    if (result.diagnostics.some((diagnostic) => diagnostic.level === "error")) {
+      failed = true;
+      continue;
+    }
+    const count = result.rules.length;
+    io.stdout(`${shown}: ${count} ${count === 1 ? "rule" : "rules"} valid
+`);
+  }
+  return failed ? 2 : 0;
+}
+
+// src/commands/warm.ts
+import { parseArgs as parseArgs6 } from "util";
+var WARM_TIMEOUT_MS = 5 * 6e4;
+async function warmCommand(root, args, registry, io) {
+  const { values } = parseArgs6({ args, options: { detector: { type: "string", multiple: true } } });
+  if (!hasProject(root)) throw new Error(`no .rulecast-config.yaml in ${root} or its parents (run rulecast init)`);
+  const home = cacheHome(io.env);
+  const stateDir = ensureProjectState(home, root);
+  const log = debugLogger(stateDir);
+  const result = await warmDetectors({
+    root,
+    stateDir,
+    // Hooks start warm-ups detached, so like hooks it never fetches rule repos.
+    project: await compile({ root, registry, repos: cachedRepos(home) }),
+    registry,
+    kinds: values.detector ?? null,
+    timeoutMs: WARM_TIMEOUT_MS
+  });
+  if (result.warmed.length > 0) io.stdout(`rulecast: warmed ${result.warmed.join(", ")}
+`);
+  if (result.skipped.length > 0) io.stdout(`rulecast: already warming ${result.skipped.join(", ")}
+`);
+  for (const error of result.errors) {
+    log(`warm ${error.kind} failed: ${error.message}`);
+    io.stderr(`rulecast: warm ${error.kind} failed: ${error.message}
+`);
+  }
+  if (result.warmed.length + result.skipped.length + result.errors.length === 0) {
+    io.stdout("rulecast: nothing to warm\n");
+  }
+  return result.errors.length > 0 ? 2 : 0;
+}
+
+// src/commands/main.ts
+var USAGE = `usage:
+  rulecast init [--rules id,id | --no-rules] [--agent <name>]... [--scope shared|personal] [--yes]
+  rulecast install [--agent <name>]... [--scope shared|personal]
+  rulecast uninstall [--agent <name>]...
+  rulecast run [RULE_ID] [--all-files | --files F...] [--from-ref A [--to-ref B]] [--format terminal|agent|json|sarif] [--session <id>] [--no-llm]
+  rulecast autoupdate [--freeze] [--repo URL]...
+  rulecast try-repo <path|url> [RULE_ID] [--ref REV] [run flags]
+  rulecast validate [file...]
+  rulecast clean [--project]
+  rulecast hook <adapter>
+  rulecast warm [--detector <kind>]...
+  rulecast doctor
+`;
+async function main(argv, io) {
+  const [command, ...args] = argv;
+  const registry = createRegistry([...builtinDetectors]);
+  const root = findRoot(io.cwd);
+  try {
+    switch (command) {
+      case "init":
+        return await initCommand(args, registry, io);
+      case "install":
+        return await installCommand(root, args, io);
+      case "uninstall":
+        return await uninstallCommand(root, args, io);
+      case "run":
+        return await runCommand(root, args, registry, io);
+      case "autoupdate":
+        return await autoupdateCommand(root, args, io);
+      case "try-repo":
+        return await tryRepoCommand(root, args, registry, io);
+      case "validate":
+        return await validateCommand(root, args, registry, io);
+      case "clean":
+        return await cleanCommand(root, args, io);
+      case "hook":
+        return await hookCommand(args, registry, io);
+      case "warm":
+        return await warmCommand(root, args, registry, io);
+      case "doctor":
+        return await doctorCommand(root, args, registry, io);
+      case void 0:
+      case "help":
+      case "--help":
+        io.stdout(USAGE);
+        return command === void 0 ? 2 : 0;
+      default:
+        throw new UsageError(`unknown command "${command}"`);
+    }
+  } catch (error) {
+    io.stderr(`rulecast: ${errorMessage(error)}
+`);
+    if (error instanceof UsageError || error.code?.startsWith("ERR_PARSE_ARGS")) {
+      io.stderr(USAGE);
+    }
+    return 2;
+  }
+}
+
+// src/commands/spawn.ts
+import { spawn } from "child_process";
+function spawnDetached(command, args, cwd) {
+  const child = spawn(command, args, { cwd, detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+
+// src/init/clipboard.ts
+import { spawn as spawn2 } from "child_process";
+import { accessSync, constants, statSync as statSync3 } from "fs";
+import path9 from "path";
+var CANDIDATES = [
+  { command: "pbcopy", args: [] },
+  { command: "wl-copy", args: [] },
+  { command: "xclip", args: ["-selection", "clipboard"] },
+  { command: "clip.exe", args: [] }
+];
+function isExecutable(file) {
+  try {
+    if (!statSync3(file).isFile()) return false;
+    accessSync(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findOnPath(name, env) {
+  for (const dir of (env.PATH ?? "").split(path9.delimiter)) {
+    if (dir === "") continue;
+    const candidate = path9.join(dir, name);
+    if (isExecutable(candidate)) return candidate;
+  }
+  return null;
+}
+function clipboardCommand(env) {
+  for (const candidate of CANDIDATES) {
+    const found = findOnPath(candidate.command, env);
+    if (found !== null) return { command: found, args: candidate.args };
+  }
+  return null;
+}
+function copyWith(clipboard, text) {
+  return new Promise((resolve) => {
+    const child = spawn2(clipboard.command, clipboard.args, { stdio: ["pipe", "ignore", "ignore"] });
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(text);
+  });
+}
+
+// src/cli.ts
+var script = process.argv[1];
+process.exitCode = await main(process.argv.slice(2), {
+  cwd: process.cwd(),
+  env: process.env,
+  interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+  stdout: (text) => process.stdout.write(text),
+  stderr: (text) => process.stderr.write(text),
+  readStdin: () => readAll(process.stdin),
+  startWarm: (root, kinds) => spawnDetached(process.execPath, [script, "warm", ...kinds.flatMap((kind) => ["--detector", kind])], root),
+  // Only init prompts; a dynamic import keeps @clack/prompts out of every hook's startup.
+  prompter: async () => (await import("./clack-YPV4ZOQK.js")).clackPrompter(),
+  copyToClipboard: async (text) => {
+    const clipboard = clipboardCommand(process.env);
+    return clipboard !== null && await copyWith(clipboard, text);
+  }
+});