codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/rule-proposals.js

@@ -0,0 +1,104 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rule_proposals_exports = {};
+__export(rule_proposals_exports, {
+  addRuleProposal: () => addRuleProposal,
+  decideRuleProposal: () => decideRuleProposal,
+  getRuleProposal: () => getRuleProposal,
+  listRuleProposals: () => listRuleProposals
+});
+module.exports = __toCommonJS(rule_proposals_exports);
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+const COLS = "uid, project_root, rule_id, body, why, effect, words, author, author_type, session_id, status, created_at, decided_at, decided_by, decided_by_type, decision_note";
+function fromRow(r) {
+  let body = null;
+  try {
+    body = r[3] == null ? null : JSON.parse(String(r[3]));
+  } catch {
+    body = null;
+  }
+  return {
+    uid: String(r[0]),
+    projectRoot: String(r[1]),
+    ruleId: String(r[2]),
+    body,
+    why: String(r[4]),
+    effect: r[5] == null ? null : String(r[5]),
+    words: String(r[6]),
+    author: String(r[7]),
+    authorType: String(r[8]),
+    sessionId: r[9] == null ? null : String(r[9]),
+    status: String(r[10]),
+    createdAt: Number(r[11]),
+    decidedAt: r[12] == null ? null : Number(r[12]),
+    decidedBy: r[13] == null ? null : String(r[13]),
+    decidedByType: r[14] == null ? null : String(r[14]),
+    decisionNote: r[15] == null ? null : String(r[15])
+  };
+}
+function addRuleProposal(input, now = Date.now()) {
+  const uid = (0, import_node_crypto.randomUUID)();
+  (0, import_database.getDb)().run(
+    `INSERT INTO rule_proposals (uid, project_root, rule_id, body, why, effect, words, author, author_type, session_id, status, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'open', ?)`,
+    [
+      uid,
+      input.projectRoot,
+      input.ruleId,
+      input.body ? JSON.stringify(input.body) : null,
+      input.why,
+      input.effect,
+      input.words,
+      input.author,
+      input.authorType,
+      input.sessionId,
+      now
+    ]
+  );
+  (0, import_persistence.markDirty)();
+  return getRuleProposal(uid);
+}
+function getRuleProposal(uid) {
+  const r = (0, import_database.getDb)().exec(`SELECT ${COLS} FROM rule_proposals WHERE uid = ?`, [uid])[0]?.values[0];
+  return r ? fromRow(r) : null;
+}
+function listRuleProposals(projectRoot, status) {
+  const where = status ? "AND status = ?" : "";
+  const rows = (0, import_database.getDb)().exec(
+    `SELECT ${COLS} FROM rule_proposals WHERE project_root = ? ${where} ORDER BY (status = 'open') DESC, created_at DESC LIMIT 200`,
+    status ? [projectRoot, status] : [projectRoot]
+  )[0]?.values ?? [];
+  return rows.map(fromRow);
+}
+function decideRuleProposal(uid, status, by, note, now = Date.now()) {
+  (0, import_database.getDb)().run(
+    `UPDATE rule_proposals SET status = ?, decided_at = ?, decided_by = ?, decided_by_type = ?, decision_note = ? WHERE uid = ? AND status = 'open'`,
+    [status, now, by.author, by.authorType, note, uid]
+  );
+  (0, import_persistence.markDirty)();
+  return getRuleProposal(uid);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addRuleProposal,
+  decideRuleProposal,
+  getRuleProposal,
+  listRuleProposals
+});

package/src/backend/services/rule-scope.js

@@ -0,0 +1,76 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rule_scope_exports = {};
+__export(rule_scope_exports, {
+  inScope: () => inScope,
+  parseScope: () => parseScope,
+  ruleTouches: () => ruleTouches,
+  scopeRules: () => scopeRules,
+  scopeWords: () => scopeWords
+});
+module.exports = __toCommonJS(rule_scope_exports);
+var import_architecture_rule = require("./architecture-rule");
+function parseScope(raw) {
+  const list = (v) => {
+    const items = (Array.isArray(v) ? v : typeof v === "string" ? v.split(",") : []).filter((x) => typeof x === "string").map((x) => x.trim().replace(/^\.\/+/, "")).filter(Boolean);
+    return items.length ? [...new Set(items)].slice(0, 50) : void 0;
+  };
+  const scope = { suites: list(raw.suite), rules: list(raw.rule), paths: list(raw.path), engines: list(raw.engine), strengths: list(raw.strength), tags: list(raw.tag) };
+  if (!scope.engines) delete scope.engines;
+  if (!scope.strengths) delete scope.strengths;
+  if (!scope.tags) delete scope.tags;
+  return scope.suites || scope.rules || scope.paths || scope.engines || scope.strengths || scope.tags ? scope : null;
+}
+function ruleTouches(rule, p) {
+  if ((0, import_architecture_rule.inPattern)(rule.from, p)) return true;
+  const folder = p.endsWith("/") ? p : `${p}/`;
+  return rule.from.startsWith(folder) || rule.from === p;
+}
+function inScope(rule, scope) {
+  if (!scope) return true;
+  if (scope.suites && !(rule.suite && scope.suites.includes(rule.suite))) return false;
+  if (scope.rules && !scope.rules.includes(rule.id)) return false;
+  if (scope.paths && !scope.paths.some((p) => ruleTouches(rule, p))) return false;
+  if (scope.engines && !scope.engines.includes((0, import_architecture_rule.ruleEngine)(rule))) return false;
+  if (scope.strengths && !scope.strengths.includes(rule.strength)) return false;
+  if (scope.tags && !scope.tags.some((t) => rule.tags?.includes(t))) return false;
+  return true;
+}
+function scopeRules(rules, scope) {
+  return rules.filter((r) => inScope(r, scope));
+}
+function scopeWords(scope) {
+  if (!scope) return "every rule";
+  const part = (one, many, xs) => xs ? `${xs.length === 1 ? one : many} ${xs.join(", ")}` : null;
+  return [
+    part("suite", "suites", scope.suites),
+    part("rule", "rules", scope.rules),
+    part("rules about", "rules about", scope.paths),
+    part("engine", "engines", scope.engines),
+    part("strength", "strengths", scope.strengths),
+    part("tag", "tags", scope.tags)
+  ].filter(Boolean).join("; ");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inScope,
+  parseScope,
+  ruleTouches,
+  scopeRules,
+  scopeWords
+});

package/src/backend/services/rulebook.js

@@ -0,0 +1,286 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rulebook_exports = {};
+__export(rulebook_exports, {
+  RULES_DIR: () => RULES_DIR,
+  isSuiteName: () => isSuiteName,
+  parseSuite: () => parseSuite,
+  readRulebook: () => readRulebook,
+  rulebookFrom: () => rulebookFrom,
+  suiteFile: () => suiteFile,
+  writeSuite: () => writeSuite
+});
+module.exports = __toCommonJS(rulebook_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_yaml = require("yaml");
+var import_architecture_rule = require("./architecture-rule");
+var import_confined_fs = require("./confined-fs");
+const RULES_DIR = ".codetrellis/rules";
+const SUITE_RE = /^[a-z0-9][a-z0-9-]{0,62}$/;
+const RESERVED = /* @__PURE__ */ new Set(["baseline"]);
+function isSuiteName(name) {
+  return typeof name === "string" && SUITE_RE.test(name) && !RESERVED.has(name);
+}
+const suiteFile = (name) => `${RULES_DIR}/${name}.yaml`;
+function parseSuite(name, text) {
+  const file = suiteFile(name);
+  const problems = [];
+  const doc = (0, import_yaml.parseDocument)(text);
+  if (doc.errors.length > 0) {
+    return { suite: null, problems: [`${file} is not valid YAML: ${doc.errors[0].message.split("\n")[0]}`] };
+  }
+  const data = doc.toJS();
+  if (data === null || data === void 0) return { suite: { name, file, because: "", rules: [] }, problems };
+  if (typeof data !== "object" || Array.isArray(data)) {
+    return { suite: null, problems: [`${file} must be a suite: a mapping with a list of rules`] };
+  }
+  const d = data;
+  if (d.suite !== void 0 && d.suite !== name) problems.push(`${file} says it is suite "${String(d.suite)}"; a suite is named by its file, so it is read as "${name}"`);
+  if (d.rules !== void 0 && !Array.isArray(d.rules)) {
+    return { suite: null, problems: [...problems, `${file}: rules must be a list`] };
+  }
+  const rules = [];
+  const seen = /* @__PURE__ */ new Set();
+  (d.rules ?? []).forEach((raw, i) => {
+    const label = raw && typeof raw === "object" && typeof raw.id === "string" ? `rule "${raw.id}"` : `rule ${i + 1}`;
+    const { rule, problems: why } = (0, import_architecture_rule.parseArchitectureRule)(raw);
+    if (!rule) {
+      problems.push(`${file}, ${label}: ${why.join("; ")}`);
+      return;
+    }
+    if (seen.has(rule.id)) {
+      problems.push(`${file}, ${label}: the id is used twice in this suite; the first is kept`);
+      return;
+    }
+    seen.add(rule.id);
+    rules.push({ ...rule, suite: name });
+  });
+  return { suite: { name, file, because: typeof d.because === "string" ? d.because.trim() : "", rules }, problems };
+}
+function suiteNames(projectRoot) {
+  let dir;
+  try {
+    if (!import_node_fs.default.existsSync(import_node_path.default.join(projectRoot, RULES_DIR))) return [];
+    dir = (0, import_confined_fs.resolveWithin)(projectRoot, RULES_DIR, "rules folder");
+  } catch {
+    return [];
+  }
+  return import_node_fs.default.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".yaml") && isSuiteName(e.name.slice(0, -".yaml".length))).map((e) => e.name.slice(0, -".yaml".length)).sort();
+}
+const cache = /* @__PURE__ */ new Map();
+function rulebookFrom(files) {
+  const suites = [];
+  const problems = [];
+  const ids = /* @__PURE__ */ new Map();
+  for (const { name, text } of [...files].sort((a, b) => a.name.localeCompare(b.name))) {
+    const parsed = parseSuite(name, text);
+    problems.push(...parsed.problems);
+    if (!parsed.suite) continue;
+    const kept = parsed.suite.rules.filter((r) => {
+      const other = ids.get(r.id);
+      if (other) {
+        problems.push(`${suiteFile(name)}, rule "${r.id}": the id is already used in suite "${other}"; that one is kept`);
+        return false;
+      }
+      ids.set(r.id, name);
+      return true;
+    });
+    suites.push({ ...parsed.suite, rules: kept });
+  }
+  return { suites, problems };
+}
+function readRulebook(projectRoot) {
+  const names = suiteNames(projectRoot);
+  const stamps = names.map((n) => {
+    try {
+      const st = import_node_fs.default.statSync(import_node_path.default.join(projectRoot, suiteFile(n)));
+      return `${n}:${st.size}:${st.mtimeMs}`;
+    } catch {
+      return `${n}:?`;
+    }
+  });
+  const key = stamps.join("|");
+  const hit = cache.get(projectRoot);
+  if (hit && hit.key === key) return hit.book;
+  const files = [];
+  const unread = [];
+  for (const name of names) {
+    try {
+      files.push({ name, text: (0, import_confined_fs.readTextWithin)(projectRoot, suiteFile(name), "rule suite") });
+    } catch (err) {
+      unread.push(`${suiteFile(name)} could not be read: ${err.message}`);
+    }
+  }
+  const read = rulebookFrom(files);
+  const book = { suites: read.suites, problems: [...unread, ...read.problems] };
+  cache.set(projectRoot, { key, book });
+  return book;
+}
+function written(rule) {
+  if (rule.kind === "package") {
+    return {
+      id: rule.id,
+      kind: "package",
+      package: rule.mayNotImport,
+      ...rule.match ? { match: rule.match } : {},
+      ...rule.threshold !== void 0 ? { threshold: rule.threshold } : {},
+      ...rule.from !== "**" ? { from: rule.from } : {},
+      only: rule.only ?? [],
+      strength: rule.strength,
+      ...rule.tags?.length ? { tags: rule.tags } : {},
+      ...rule.except.length ? { except: rule.except } : {},
+      ...rule.because ? { because: rule.because } : {},
+      since: rule.since,
+      ...rule.by ? { by: rule.by } : {}
+    };
+  }
+  if (rule.kind === "folder") {
+    return {
+      id: rule.id,
+      kind: "folder",
+      folder: rule.from,
+      ...rule.files?.length ? { files: rule.files.length === 1 ? rule.files[0] : rule.files } : {},
+      ...rule.kinds?.length ? { kinds: rule.kinds } : {},
+      ...rule.exports ? { exports: rule.exports } : {},
+      strength: rule.strength,
+      ...rule.tags?.length ? { tags: rule.tags } : {},
+      ...rule.because ? { because: rule.because } : {},
+      ...rule.guide ? { guide: rule.guide } : {},
+      since: rule.since,
+      ...rule.by ? { by: rule.by } : {}
+    };
+  }
+  if (rule.kind === "calls") {
+    return {
+      id: rule.id,
+      kind: "calls",
+      calls: rule.mayNotImport,
+      ...rule.match ? { match: rule.match } : {},
+      ...rule.threshold !== void 0 ? { threshold: rule.threshold } : {},
+      ...rule.from !== "**" ? { from: rule.from } : {},
+      only: rule.only ?? [],
+      strength: rule.strength,
+      ...rule.tags?.length ? { tags: rule.tags } : {},
+      ...rule.because ? { because: rule.because } : {},
+      since: rule.since,
+      ...rule.by ? { by: rule.by } : {}
+    };
+  }
+  if (rule.kind === "agent") {
+    return {
+      id: rule.id,
+      engine: "agent",
+      rule: rule.mayNotImport,
+      in: rule.in ?? [],
+      ...rule.except.length ? { except: rule.except } : {},
+      strength: rule.strength,
+      ...rule.tags?.length ? { tags: rule.tags } : {},
+      ...rule.because ? { because: rule.because } : {},
+      since: rule.since,
+      ...rule.by ? { by: rule.by } : {}
+    };
+  }
+  if (rule.kind === "grep") {
+    return {
+      id: rule.id,
+      kind: "grep",
+      in: rule.in ?? [],
+      ...rule.except.length ? { except: rule.except } : {},
+      [rule.must ? "must" : "mustNot"]: rule.mayNotImport,
+      ...rule.match ? { match: rule.match } : {},
+      ...rule.threshold !== void 0 ? { threshold: rule.threshold } : {},
+      ...rule.ignoreCase ? { ignoreCase: true } : {},
+      strength: rule.strength,
+      ...rule.tags?.length ? { tags: rule.tags } : {},
+      ...rule.because ? { because: rule.because } : {},
+      since: rule.since,
+      ...rule.by ? { by: rule.by } : {}
+    };
+  }
+  if (rule.kind === "symbol") {
+    return {
+      id: rule.id,
+      kind: "symbol",
+      symbol: rule.mayNotImport,
+      ...rule.match ? { match: rule.match } : {},
+      ...rule.threshold !== void 0 ? { threshold: rule.threshold } : {},
+      ...rule.from !== "**" ? { from: rule.from } : {},
+      only: rule.only ?? [],
+      strength: rule.strength,
+      ...rule.tags?.length ? { tags: rule.tags } : {},
+      ...rule.because ? { because: rule.because } : {},
+      since: rule.since,
+      ...rule.by ? { by: rule.by } : {}
+    };
+  }
+  return {
+    id: rule.id,
+    from: rule.from,
+    mayNotImport: rule.mayNotImport,
+    strength: rule.strength,
+    ...rule.tags?.length ? { tags: rule.tags } : {},
+    ...rule.except.length ? { except: rule.except } : {},
+    ...rule.because ? { because: rule.because } : {},
+    since: rule.since,
+    ...rule.by ? { by: rule.by } : {}
+  };
+}
+function writeSuite(projectRoot, name, rules) {
+  if (!isSuiteName(name)) throw new Error(`"${name}" is not a suite name: lowercase letters, digits and dashes, like payments`);
+  const file = suiteFile(name);
+  let doc;
+  let existing = null;
+  try {
+    if (import_node_fs.default.existsSync(import_node_path.default.join(projectRoot, file))) existing = (0, import_confined_fs.readTextWithin)(projectRoot, file, "rule suite");
+  } catch (err) {
+    throw new Error(`${file} could not be read: ${err.message}`);
+  }
+  if (existing !== null && (0, import_yaml.parseDocument)(existing).errors.length === 0) {
+    doc = (0, import_yaml.parseDocument)(existing);
+  } else {
+    doc = new import_yaml.Document({ suite: name, rules: [] });
+    doc.commentBefore = ` Architecture rules, suite "${name}" (CodeTrellis, Phase 33 R1).
+ A person changes these in the app; CI judges a pull request by the base branch's copy.`;
+  }
+  if (!doc.has("suite")) doc.set("suite", name);
+  doc.set("rules", doc.createNode(rules.map(written)));
+  const target = (0, import_confined_fs.writeFileWithin)(projectRoot, file, doc.toString(), "rule suite");
+  cache.delete(projectRoot);
+  return target;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RULES_DIR,
+  isSuiteName,
+  parseSuite,
+  readRulebook,
+  rulebookFrom,
+  suiteFile,
+  writeSuite
+});

package/src/backend/services/rules-at.js

@@ -0,0 +1,56 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rules_at_exports = {};
+__export(rules_at_exports, {
+  rulesAt: () => rulesAt
+});
+module.exports = __toCommonJS(rules_at_exports);
+var import_git_env = require("./git-env");
+var import_architecture_rule = require("./architecture-rule");
+var import_architecture_rules = require("./architecture-rules");
+var import_rulebook = require("./rulebook");
+async function rulesAt(projectRoot, commit) {
+  if (!/^[0-9a-f]{40}$/.test(commit)) return null;
+  let listing;
+  try {
+    listing = await (0, import_git_env.gitAsync)(projectRoot, ["ls-tree", "--name-only", commit, "--", `${import_rulebook.RULES_DIR}/`]);
+  } catch {
+    return null;
+  }
+  const files = [];
+  for (const rel of listing.split("\n").map((l) => l.trim()).filter(Boolean)) {
+    const m = /^\.codetrellis\/rules\/([^/]+)\.yaml$/.exec(rel);
+    if (!m || !(0, import_rulebook.isSuiteName)(m[1])) continue;
+    try {
+      files.push({ name: m[1], text: await (0, import_git_env.gitAsync)(projectRoot, ["show", `${commit}:./${rel}`]) });
+    } catch {
+    }
+  }
+  const book = (0, import_rulebook.rulebookFrom)(files);
+  let fromConfig = [];
+  try {
+    const raw = JSON.parse(await (0, import_git_env.gitAsync)(projectRoot, ["show", `${commit}:./.codetrellis/config.json`]));
+    if (Array.isArray(raw.rules)) fromConfig = raw.rules.map((r) => (0, import_architecture_rule.parseArchitectureRule)(r).rule).filter((r) => !!r);
+  } catch {
+  }
+  return { rules: (0, import_architecture_rules.combineRules)(book.suites.flatMap((s) => s.rules), fromConfig), problems: book.problems };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rulesAt
+});

package/src/backend/services/rules-overview.js

@@ -0,0 +1,88 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rules_overview_exports = {};
+__export(rules_overview_exports, {
+  debtByRule: () => debtByRule,
+  ruleHistory: () => ruleHistory,
+  suiteSummaries: () => suiteSummaries
+});
+module.exports = __toCommonJS(rules_overview_exports);
+var import_database = require("./database");
+var import_rule_baseline = require("./rule-baseline");
+var import_tool_phrasing = require("../../shared/lib/tool-phrasing");
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function debtByRule(projectRoot) {
+  const base = (0, import_rule_baseline.readBaseline)(projectRoot);
+  return new Map([...base ?? /* @__PURE__ */ new Map()].map(([id, entries]) => [id, entries.size]));
+}
+function suiteSummaries(views, debt) {
+  const by = /* @__PURE__ */ new Map();
+  for (const v of views) {
+    const k = v.rule.suite ?? "config.json";
+    by.set(k, [...by.get(k) ?? [], v]);
+  }
+  return [...by].map(([suite, vs]) => {
+    const checked = vs.filter((v) => v.rule.strength !== "guide");
+    const unknown = checked.some((v) => v.breaches === null);
+    const breaches = unknown ? null : checked.reduce((n, v) => n + (v.breaches?.length ?? 0), 0);
+    const owed = vs.reduce((n, v) => n + (debt.get(v.rule.id) ?? 0), 0);
+    const status = unknown ? "unknown" : breaches > 0 ? "breaks" : "holds";
+    const words = [
+      plural(vs.length, "rule"),
+      breaches === null ? "open the project to see what breaks them" : breaches === 0 ? "nothing breaks them today" : `${plural(breaches, "import")} ${breaches === 1 ? "breaks" : "break"} them today`,
+      ...owed ? [`${plural(owed, "old breach", "old breaches")} in the baseline`] : []
+    ].join(" \xB7 ");
+    return { suite, where: vs[0].where, rules: vs.length, breaches, debt: owed, status, words };
+  }).sort((a, b) => a.suite.localeCompare(b.suite));
+}
+function ruleHistory(projectRoot, limit = 100) {
+  let rows = [];
+  try {
+    rows = (0, import_database.getDb)().exec(
+      `SELECT id, at, source, type, payload FROM agent_events WHERE type = 'rule_changed' ORDER BY at DESC LIMIT 2000`
+    )[0]?.values ?? [];
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const r of rows) {
+    let payload = {};
+    try {
+      payload = JSON.parse(String(r[4]));
+    } catch {
+      continue;
+    }
+    if (payload.projectRoot !== projectRoot) continue;
+    const phrased = (0, import_tool_phrasing.phraseEvent)({ id: String(r[0]), timestamp: Number(r[1]), source: String(r[2]), type: String(r[3]), payload });
+    out.push({
+      at: Number(r[1]),
+      ruleId: typeof payload.ruleId === "string" ? payload.ruleId : null,
+      change: String(payload.change ?? "changed"),
+      by: String(payload.author ?? "someone"),
+      words: phrased.text
+    });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debtByRule,
+  ruleHistory,
+  suiteSummaries
+});