@hawkeyexl/manni 4.3.1 → 4.4.1

package/dist/cli-PYPX6O6E.js

@@ -0,0 +1,739 @@
+#!/usr/bin/env node
+import {
+  readStdin
+} from "./chunk-TZOYZK2E.js";
+import "./chunk-UKZNLVJW.js";
+import "./chunk-QRWGPQKO.js";
+import "./chunk-A5ULMVHQ.js";
+import {
+  memberOf,
+  retainMembers
+} from "./chunk-M3W7J6MU.js";
+import "./chunk-IDV6HJCB.js";
+import {
+  extractorForExtension,
+  resolveTargetSet,
+  supportedExtensions,
+  withSharedWalks
+} from "./chunk-57NEQRVO.js";
+import {
+  fail
+} from "./chunk-YEUYKR62.js";
+import {
+  shouldColor
+} from "./chunk-RNVYGWIC.js";
+import "./chunk-MNH7QO4Z.js";
+import {
+  findFamilyConfigFile,
+  notice,
+  readFamilyConfigFile
+} from "./chunk-Q35YIDBV.js";
+import {
+  package_default
+} from "./chunk-UJCVAWP7.js";
+import {
+  programName
+} from "./chunk-OWBRDNRZ.js";
+import {
+  ToolError,
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+import "./chunk-2H7UOFLK.js";
+
+// src/family/cli.ts
+import { resolve as resolve5 } from "node:path";
+import { Command, Option } from "commander";
+
+// src/family/core/envelope.ts
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function parseEnvelope(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  const doc = record(parsed);
+  const event = str(doc?.hook_event_name);
+  if (doc === void 0 || event === void 0) return void 0;
+  const input = record(doc.tool_input);
+  const filePath = str(input?.file_path) ?? str(input?.notebook_path);
+  const cwd = str(doc.cwd);
+  const toolName = str(doc.tool_name);
+  const model = str(doc.model) ?? str(record(doc.model)?.id);
+  return {
+    event,
+    stopHookActive: doc.stop_hook_active === true,
+    ...cwd === void 0 ? {} : { cwd },
+    ...toolName === void 0 ? {} : { toolName },
+    ...filePath === void 0 ? {} : { filePath },
+    ...model === void 0 ? {} : { model }
+  };
+}
+async function readEnvelope(stream = process.stdin) {
+  if (stream.isTTY) return void 0;
+  try {
+    return parseEnvelope(await readStdin(stream));
+  } catch {
+    return void 0;
+  }
+}
+
+// src/family/core/in-play.ts
+import { relative, resolve, sep } from "node:path";
+import { parse as parseYaml } from "yaml";
+var FamilyError = class extends ToolError {
+  constructor(message, quiet = false) {
+    super(message);
+    this.quiet = quiet;
+    this.name = "FamilyError";
+  }
+  quiet;
+};
+function noConfigError(cwd) {
+  return new FamilyError(
+    `No manni.config.yaml found from ${cwd} up to the repository root. manni check runs the checks it sets up.`,
+    true
+  );
+}
+function nothingSetUpError() {
+  return new FamilyError(
+    "Nothing is set up to check in manni.config.yaml. manni status says what each domain needs.",
+    true
+  );
+}
+var DOMAINS = ["meta", "cite", "lint", "docevals", "term", "graph"];
+var COMMANDS = {
+  meta: "meta validate",
+  cite: "cite check",
+  lint: "lint check",
+  docevals: "docevals run",
+  term: "term check",
+  graph: "graph check"
+};
+var NOT_SET_UP = {
+  meta: "no meta: section",
+  cite: "no page carries citations",
+  lint: "no lint: section",
+  docevals: "no page resolves any evals",
+  term: "no terms in any collection",
+  graph: "no graph: section"
+};
+var META_DEFAULTS_ONLY = "only the built-in default schemas cover these files";
+var NOT_CHECKED = [
+  ["a11y", "run manni a11y check against a running site"],
+  ["tracevals", "run manni tracevals run over sessions"]
+];
+function plural(n, one, many = `${one}s`) {
+  return `${String(n)} ${n === 1 ? one : many}`;
+}
+function toError(message) {
+  return new FamilyError(message);
+}
+async function loadFamily(cwd, configPath) {
+  const file = configPath === void 0 ? await findFamilyConfigFile(cwd, toError) : await readFamilyConfigFile(configPath, cwd, toError);
+  if (file === null) throw noConfigError(cwd);
+  const doc = parseYaml(file.text);
+  const sections = doc !== null && typeof doc === "object" && !Array.isArray(doc) ? new Set(Object.keys(doc)) : /* @__PURE__ */ new Set();
+  return { file, configPath: configPath ?? file.source, sections, collections: file.collections };
+}
+function labelFrom(cwd, path) {
+  return relative(cwd, path).split(sep).join("/");
+}
+function collectionsOf(family, cwd, label) {
+  return memberOf(family.collections, family.file.dir, cwd, label);
+}
+async function listMembers(family, cwd) {
+  const dir = family.file.dir;
+  const { files } = await resolveTargetSet({
+    inputs: family.collections.flatMap((c) => c.paths),
+    cwd: dir,
+    allowEmpty: true
+  });
+  return retainMembers(files, (label) => memberOf(family.collections, dir, dir, label)).map(
+    (label) => labelFrom(cwd, resolve(dir, label))
+  );
+}
+
+// src/family/commands/check.ts
+import { extname, resolve as resolve3 } from "node:path";
+
+// src/family/core/changed.ts
+import { execFile } from "node:child_process";
+import { posix, resolve as resolve2 } from "node:path";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+async function git(args, cwd) {
+  const { stdout } = await run("git", args, {
+    cwd,
+    shell: false,
+    windowsHide: true,
+    maxBuffer: 64 * 1024 * 1024
+  });
+  return stdout;
+}
+function parsePorcelain(output) {
+  const fields = output.split("\0");
+  const files = [];
+  const removed = [];
+  for (let i = 0; i < fields.length; i++) {
+    const entry = fields[i] ?? "";
+    if (entry.length < 4) continue;
+    const xy = entry.slice(0, 2);
+    const path = entry.slice(3);
+    if (xy.includes("R") || xy.includes("C")) {
+      i++;
+      if (xy.includes("R")) removed.push(fields[i] ?? "");
+    }
+    if (xy.includes("D")) removed.push(path);
+    else files.push(path);
+  }
+  return { files, removed };
+}
+async function changedFiles(cwd) {
+  const prefix = (await git(["rev-parse", "--show-prefix"], cwd)).trim();
+  const status = await git(
+    ["status", "--porcelain=v1", "-z", "--untracked-files=all"],
+    cwd
+  );
+  const { files, removed } = parsePorcelain(status);
+  const absolute = (path) => resolve2(cwd, posix.relative(prefix, path));
+  return { files: files.map(absolute), removed: removed.map(absolute), dirty: status.length > 0 };
+}
+
+// src/family/commands/check.ts
+var CHECK_FORMATS = ["pretty", "json", "github"];
+async function runDomain(domain, ctx) {
+  const { family, cwd, inputs, onNotice } = ctx;
+  const configPath = family.configPath;
+  switch (domain) {
+    case "meta": {
+      const [{ runValidate }, { render: renderMeta }] = await Promise.all([
+        import("./validate-53RKM2XG.js"),
+        import("./reporters-K2VUKSAK.js")
+      ]);
+      const run2 = await runValidate({ inputs, configPath, cwd, skipDefaultOnly: true, onNotice });
+      if (run2.results.length === 0) {
+        return { skipped: family.sections.has("meta") ? META_DEFAULTS_ONLY : NOT_SET_UP.meta };
+      }
+      return {
+        failed: run2.summary.failed > 0,
+        render: (format, color) => renderMeta(format, run2.results, run2.summary, { color, quiet: true, frame: run2.frame, onNotice })
+      };
+    }
+    case "cite": {
+      const [{ runCheck: runCite }, { renderCheckPretty: citePretty }, { renderCheckJson: citeJson }, { renderCheckGithub: citeGithub }] = await Promise.all([
+        import("./check-ASPIHA6B.js"),
+        import("./pretty-CXSDXNAS.js"),
+        import("./json-7WV7KL6H.js"),
+        import("./github-SXPGP5DB.js")
+      ]);
+      const run2 = await runCite({ inputs, configPath, cwd, onNotice });
+      if (!run2.pages.some((p) => p.citations.length > 0 || p.findings.length > 0)) {
+        return { skipped: NOT_SET_UP.cite };
+      }
+      return {
+        failed: run2.summary.failed > 0,
+        render: (format, color) => format === "json" ? citeJson(run2) : format === "github" ? citeGithub(run2) : citePretty(run2, { color, quiet: true })
+      };
+    }
+    case "lint": {
+      if (!family.sections.has("lint")) return { skipped: NOT_SET_UP.lint };
+      const [{ runLint }, { render: renderLint }] = await Promise.all([
+        import("./lint-ASMJLLPA.js"),
+        import("./reporters-HUY7UXFS.js")
+      ]);
+      const run2 = await runLint({ inputs, configPath, cwd, onNotice });
+      return {
+        failed: run2.summary.failed > 0,
+        render: (format, color) => renderLint(run2, format, { color })
+      };
+    }
+    case "docevals": {
+      const [{ runRun: runDocevals }, { render: renderDocevals }, { DocevalsError }] = await Promise.all([
+        import("./run-3DYJNRIG.js"),
+        import("./reporters-M6LJ2IYU.js"),
+        import("./types-Y6TXHM7M.js")
+      ]);
+      let report;
+      try {
+        report = await runDocevals(inputs, {
+          config: configPath,
+          cwd,
+          deterministicOnly: true,
+          generate: false,
+          execution: false,
+          toolVersion: package_default.version
+        });
+      } catch (err) {
+        if (err instanceof DocevalsError && err.code === "nothing-resolved") {
+          return { skipped: NOT_SET_UP.docevals };
+        }
+        throw err;
+      }
+      return {
+        failed: report.exitCode !== 0,
+        render: (format, color) => renderDocevals(report, format, { color })
+      };
+    }
+    case "term": {
+      const [{ runCheck: runTerm }, { renderFindingsPretty: termPretty }, { renderFindingsJson: termJson }, { renderFindingsGithub: termGithub }] = await Promise.all([
+        import("./check-EDLBYL5N.js"),
+        import("./pretty-A5EGTN35.js"),
+        import("./json-SY7KLNC7.js"),
+        import("./github-6QMYOHC3.js")
+      ]);
+      const report = await runTerm({ inputs, configPath, cwd, allowEmpty: true, onNotice });
+      if (report.terms === 0) return { skipped: NOT_SET_UP.term };
+      return {
+        failed: report.summary.failed > 0,
+        render: (format, color) => format === "json" ? termJson(report) : format === "github" ? termGithub(report) : termPretty(report, { color, references: true })
+      };
+    }
+    case "graph": {
+      if (!family.sections.has("graph")) return { skipped: NOT_SET_UP.graph };
+      const [{ buildGraph }, { runCheck: runGraph, renderCheck: renderGraph }] = await Promise.all([
+        import("./build-COYIQ25L.js"),
+        import("./check-HYNGXYJV.js")
+      ]);
+      const built = await buildGraph({ config: configPath, cwd });
+      for (const warning of built.warnings) onNotice(warning);
+      const report = await runGraph({ config: configPath, cwd, turtle: built.turtle });
+      return {
+        failed: report.exitCode !== 0,
+        render: (format) => renderGraph(report, format)
+      };
+    }
+  }
+}
+async function outcome(domain, ctx) {
+  const command = COMMANDS[domain];
+  try {
+    const result = await runDomain(domain, ctx);
+    if ("skipped" in result) return { command, status: "skipped", message: result.skipped };
+    return { command, status: result.failed ? "fail" : "pass", render: result.render };
+  } catch (err) {
+    return { command, status: "error", message: errorMessage(err) };
+  }
+}
+function isDocument(label) {
+  return supportedExtensions().includes(extname(label).toLowerCase());
+}
+function runFamilyCheck(opts) {
+  return withSharedWalks(() => checkUnshared(opts));
+}
+async function checkUnshared(opts) {
+  const cwd = resolve3(opts.cwd ?? process.cwd());
+  const onNotice = opts.onNotice ?? (() => void 0);
+  const family = await loadFamily(cwd, opts.configPath);
+  if (family.collections.length === 0) throw nothingSetUpError();
+  const isMember = (label) => collectionsOf(family, cwd, label).length > 0;
+  let files;
+  let domains;
+  let inputs;
+  switch (opts.scope.kind) {
+    case "all":
+      files = await listMembers(family, cwd);
+      inputs = [];
+      domains = [...DOMAINS];
+      break;
+    case "paths": {
+      const { files: named } = await resolveTargetSet({
+        inputs: opts.scope.paths,
+        cwd,
+        ...opts.allowMissing === true ? { allowEmpty: true } : {}
+      });
+      const outside = named.filter((label) => !isMember(label));
+      if (outside.length > 0) {
+        onNotice(`Skipped ${plural(outside.length, "file")} outside every collection: ${outside.join(", ")}`);
+      }
+      files = named.filter((label) => isMember(label) && isDocument(label));
+      inputs = files;
+      domains = files.length > 0 ? ["meta", "cite", "lint", "docevals"] : [];
+      break;
+    }
+    case "changed": {
+      const changed = await changedFiles(cwd);
+      if (!changed.dirty) return { status: "pass", files: [], checks: [] };
+      const memberDocuments = (paths) => paths.map((path) => labelFrom(cwd, path)).filter((l) => isDocument(l) && isMember(l));
+      files = memberDocuments(changed.files);
+      inputs = files;
+      const pageChanged = files.length > 0 || memberDocuments(changed.removed).length > 0;
+      domains = [
+        ...files.length > 0 ? ["meta", "lint", "docevals"] : [],
+        "cite",
+        ...pageChanged ? ["term"] : []
+      ];
+      break;
+    }
+  }
+  const checks = [];
+  for (const domain of domains) {
+    const setWide = domain === "term" || domain === "graph" || domain === "cite" && opts.scope.kind !== "paths";
+    checks.push(await outcome(domain, { family, cwd, inputs: setWide ? [] : inputs, onNotice }));
+  }
+  if (opts.scope.kind === "all" && checks.every((c) => c.status === "skipped")) {
+    throw nothingSetUpError();
+  }
+  return { status: checks.some((c) => c.status === "fail") ? "fail" : "pass", files, checks };
+}
+function exitCodeFor(run2) {
+  if (run2.checks.some((c) => c.status === "error")) return 2;
+  return run2.status === "fail" ? 1 : 0;
+}
+function isRan(check) {
+  return check.status === "pass" || check.status === "fail";
+}
+function firstLine(message) {
+  return message.split("\n", 1)[0] ?? "";
+}
+function renderFailures(run2) {
+  return run2.checks.filter((c) => c.status === "fail").map((c) => `${c.command}
+${c.render("pretty", false)}`).join("\n\n");
+}
+function renderPretty(run2, color) {
+  const blocks = [];
+  for (const check of run2.checks) {
+    if (isRan(check)) blocks.push(`${check.command}
+${check.render("pretty", color)}`);
+  }
+  const notRun = run2.checks.filter((c) => !isRan(c));
+  if (notRun.length > 0) {
+    const width = Math.max(...notRun.map((c) => c.command.length)) + 3;
+    blocks.push(
+      notRun.map((c) => `${c.status.padEnd(9)}${c.command.padEnd(width)}${firstLine(c.message)}`).join("\n")
+    );
+  }
+  const count = (status) => run2.checks.filter((c) => c.status === status).length;
+  const errors = count("error");
+  blocks.push(
+    `${plural(run2.checks.length, "check")} over ${plural(run2.files.length, "file")}: ${String(count("fail"))} failed, ${String(count("skipped"))} skipped` + (errors > 0 ? `, ${String(errors)} could not run` : "")
+  );
+  return blocks.join("\n\n");
+}
+function jsonEntry(c) {
+  if (!isRan(c)) return { command: c.command, status: c.status, message: c.message };
+  try {
+    return { command: c.command, status: c.status, report: JSON.parse(c.render("json", false)) };
+  } catch {
+    return { command: c.command, status: "error", message: `${c.command} -f json printed output that is not JSON` };
+  }
+}
+function renderJson(run2) {
+  return JSON.stringify(
+    {
+      status: run2.status,
+      files: run2.files,
+      checks: run2.checks.map(jsonEntry)
+    },
+    null,
+    2
+  );
+}
+function renderGithub(run2) {
+  return run2.checks.filter(isRan).map((c) => c.render("github", false)).filter((text) => text.length > 0).join("\n");
+}
+function render(run2, format, color) {
+  return format === "json" ? renderJson(run2) : format === "github" ? renderGithub(run2) : renderPretty(run2, color);
+}
+var EDIT_TOOLS = ["Edit", "Write", "MultiEdit", "NotebookEdit"];
+function hookReply(run2, envelope) {
+  const failed = run2.status === "fail";
+  if (envelope.event === "PostToolUse") {
+    const files = run2.files.join(", ");
+    if (failed) {
+      return {
+        exitCode: 2,
+        stderr: `manni found errors in ${files}. Fix them before you continue.
+
+${renderFailures(run2)}
+`
+      };
+    }
+    const errors = run2.checks.filter((c) => c.status === "error");
+    if (errors.length === 0) return { exitCode: 0 };
+    const additionalContext = errors.map((c) => `manni ${c.command} could not check ${files}: ${firstLine(c.message)}`).join("\n");
+    return {
+      exitCode: 0,
+      stdout: `${JSON.stringify({ hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext } })}
+`
+    };
+  }
+  if (envelope.event === "Stop" && failed) {
+    const reply = envelope.stopHookActive ? { systemMessage: "manni still reports errors after one repair pass. Run manni check to see them." } : {
+      decision: "block",
+      reason: `manni found errors in the files you changed. Fix them, then finish.
+
+${renderFailures(run2)}`
+    };
+    return { exitCode: 0, stdout: `${JSON.stringify(reply)}
+` };
+  }
+  return { exitCode: 0 };
+}
+function hookFailure(message, envelope, file) {
+  if (envelope.event !== "PostToolUse" || file === void 0) return { exitCode: 0 };
+  const additionalContext = `manni check could not check ${file}: ${firstLine(message)}`;
+  return {
+    exitCode: 0,
+    stdout: `${JSON.stringify({ hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext } })}
+`
+  };
+}
+
+// src/family/commands/status.ts
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { extname as extname2, resolve as resolve4 } from "node:path";
+var STATUS_FORMATS = ["pretty", "json"];
+function pages(n, one, many) {
+  return n === 1 ? `1 page ${one}` : `${String(n)} pages ${many}`;
+}
+function ownSchemaCount(cwd, members) {
+  let n = 0;
+  for (const label of members) {
+    const extractor = extractorForExtension(extname2(label));
+    if (extractor === void 0) continue;
+    try {
+      const { data } = extractor.extract(readFileSync(resolve4(cwd, label), "utf8"), label);
+      if (data.$schema !== void 0) n++;
+    } catch {
+    }
+  }
+  return n;
+}
+async function citedPages(cwd, configPath) {
+  const { prepareRun, readTarget } = await import("./check-ASPIHA6B.js");
+  const { readPage } = await import("./page-KSGV5RD4.js");
+  const prepared = await prepareRun({ inputs: [], configPath, cwd, checkSources: false }, "checked", "check");
+  let n = 0;
+  for (const file of prepared.files) {
+    const content = await readTarget(prepared.run, file);
+    const { citations } = (await prepared.setupFor(file, content)).options;
+    const read = readPage(file, content, { markers: false, ...citations === void 0 ? {} : { citations } });
+    if (read.citations.length > 0) n++;
+  }
+  return n;
+}
+async function row(domain, family, cwd, members) {
+  const configPath = family.configPath;
+  const inPlay = (reason) => ({ name: domain, status: "in-play", reason });
+  const notSetUp = { name: domain, status: "not-set-up", reason: NOT_SET_UP[domain] };
+  const section = family.sections.has(domain);
+  switch (domain) {
+    case "meta": {
+      if (section) return inPlay("meta: section");
+      const n = ownSchemaCount(cwd, members);
+      return n > 0 ? inPlay(pages(n, "names its own $schema", "name their own $schema")) : notSetUp;
+    }
+    case "cite": {
+      const n = await citedPages(cwd, configPath);
+      return n > 0 ? inPlay(pages(n, "carries citations", "carry citations")) : notSetUp;
+    }
+    case "docevals": {
+      const { runList: listEvals } = await import("./list-KZNVTNVC.js");
+      const { plans } = await listEvals([], { config: configPath, cwd });
+      const n = plans.filter((p) => !p.skip && p.evals.length > 0).length;
+      if (n === 0) return notSetUp;
+      return inPlay(section ? "docevals: section" : pages(n, "declares evals", "declare evals"));
+    }
+    case "term": {
+      const { runList: listTerms } = await import("./list-Q57YTFUQ.js");
+      const { terms } = await listTerms({ inputs: [], configPath, cwd, allowEmpty: true });
+      return terms.length > 0 ? inPlay(plural(terms.length, "term")) : notSetUp;
+    }
+    case "lint":
+    case "graph":
+      return section ? inPlay(`${domain}: section`) : notSetUp;
+  }
+}
+function runStatus(opts = {}) {
+  return withSharedWalks(() => statusUnshared(opts));
+}
+async function statusUnshared(opts) {
+  const cwd = resolve4(opts.cwd ?? process.cwd());
+  const family = await loadFamily(cwd, opts.configPath);
+  const members = family.collections.length === 0 ? [] : await listMembers(family, cwd);
+  const domains = [];
+  for (const domain of DOMAINS) {
+    if (family.collections.length === 0) {
+      domains.push({ name: domain, status: "not-set-up", reason: "no collections: in manni.config.yaml" });
+      continue;
+    }
+    try {
+      domains.push(await row(domain, family, cwd, members));
+    } catch (err) {
+      const message = errorMessage(err).split("\n", 1)[0] ?? "";
+      domains.push({ name: domain, status: "unknown", reason: `manni ${COMMANDS[domain]} could not run: ${message}` });
+    }
+  }
+  for (const [name, reason] of NOT_CHECKED) domains.push({ name, status: "not-checked", reason });
+  return {
+    version: package_default.version,
+    config: family.file.source,
+    collections: family.collections.map((c) => ({
+      name: c.name,
+      files: members.filter((label) => collectionsOf(family, cwd, label).includes(c.name)).length
+    })),
+    domains
+  };
+}
+var STATE_LABEL = {
+  "in-play": "in play",
+  "not-set-up": "not set up",
+  "not-checked": "not checked",
+  unknown: "unknown"
+};
+function renderStatus(report, format) {
+  if (format === "json") return JSON.stringify(report, null, 2);
+  const head = [
+    `manni ${report.version}`,
+    `config ${report.config}`,
+    ...report.collections.map((c) => `collection ${c.name} (${plural(c.files, "file")})`)
+  ].join("   ");
+  const rows = report.domains.map(
+    (d) => `${d.name.padEnd(11)}${STATE_LABEL[d.status].padEnd(14)}${d.reason}`
+  );
+  return [head, "", ...rows].join("\n");
+}
+var FIX_SKILL = "manni:fix";
+var PAGE_WIDE = [["term", "the glossary"]];
+function prose(items, conjunction) {
+  return items.length <= 1 ? items[0] ?? "" : `${items.slice(0, -1).join(", ")} ${conjunction} ${items.at(-1) ?? ""}`;
+}
+function agentLines(report) {
+  const names = prose(report.collections.map((c) => c.name), "or");
+  const inPlay = new Set(report.domains.filter((d) => d.status === "in-play").map((d) => d.name));
+  const plus = inPlay.has("cite") ? ", plus every citation" : "";
+  const pageWide = PAGE_WIDE.filter(([domain]) => inPlay.has(domain)).map(([, what]) => what);
+  const also = pageWide.length === 0 ? "" : ` It checks ${prose(pageWide, "and")} too when you changed a page.`;
+  return [
+    `After you edit a file in ${names}, manni check runs on it, and errors come back to you at once.`,
+    `Before you finish, manni check runs on every file you changed${plus}.${also} You get one repair pass.`,
+    `The ${FIX_SKILL} skill says how to repair each finding.`
+  ].join("\n");
+}
+var MODEL_ID = /^[A-Za-z0-9._:/@-]+$/;
+function exportGeneratedBy(envelope, env = process.env) {
+  const file = env.CLAUDE_ENV_FILE;
+  const model = envelope.model?.replace(/\[[^\]]*\]$/, "");
+  if (model === void 0 || !MODEL_ID.test(model)) return false;
+  if (file === void 0 || file === "" || env.MANNI_GENERATED_BY !== void 0) return false;
+  const existing = existsSync(file) ? readFileSync(file, "utf8") : "";
+  const lead = existing === "" || existing.endsWith("\n") ? "" : "\n";
+  appendFileSync(file, `${lead}export MANNI_GENERATED_BY=${model}
+`, "utf8");
+  return true;
+}
+
+// src/family/cli.ts
+function send(reply) {
+  if (reply.stdout !== void 0) process.stdout.write(reply.stdout);
+  if (reply.stderr !== void 0) process.stderr.write(reply.stderr);
+  process.exitCode = reply.exitCode;
+}
+function hookScope(envelope, cwd) {
+  if (envelope.event === "Stop") return { scope: { kind: "changed" } };
+  if (envelope.event !== "PostToolUse") return void 0;
+  if (envelope.toolName === void 0 || !EDIT_TOOLS.includes(envelope.toolName)) return void 0;
+  if (envelope.filePath === void 0) return void 0;
+  const file = labelFrom(cwd, resolve5(cwd, envelope.filePath));
+  return { scope: { kind: "paths", paths: [file] }, file };
+}
+async function checkUnderHook(paths, options, envelope) {
+  const cwd = resolve5(envelope.cwd ?? process.cwd());
+  const asked = paths.length > 0 ? { scope: { kind: "paths", paths }, file: paths.join(", ") } : hookScope(envelope, cwd);
+  if (asked === void 0) return;
+  try {
+    const run2 = await runFamilyCheck({
+      cwd,
+      scope: asked.scope,
+      allowMissing: true,
+      ...options.config === void 0 ? {} : { configPath: options.config },
+      // stdout and stderr are the hook's channels; a notice is not for the agent.
+      onNotice: () => void 0
+    });
+    send(hookReply(run2, envelope));
+  } catch (err) {
+    if (err instanceof FamilyError && err.quiet) return;
+    send(hookFailure(errorMessage(err), envelope, asked.file));
+  }
+}
+function buildCheck() {
+  return new Command("check").description("Run every check this repository has set up, and nothing else").argument("[paths...]", "files, directories, or globs; the per-file checks run on the collection members among them").option("-c, --config <path>", "path to a manni config file").addOption(
+    new Option("-f, --format <format>", "output (not read under a hook)").choices(CHECK_FORMATS).default("pretty")
+  ).option("--no-color", "disable colored output").showHelpAfterError("(add --help for usage)").exitOverride().addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni check                       # every in-play check, the CI gate",
+      "  manni check docs/limits.md        # per-file checks on one page",
+      "  manni check -f github             # in a GitHub workflow",
+      "  manni check docs/ -f json         # scripting form"
+    ].join("\n")
+  ).action(async (paths, options) => {
+    const envelope = await readEnvelope();
+    if (envelope !== void 0) {
+      await checkUnderHook(paths, options, envelope);
+      return;
+    }
+    try {
+      const run2 = await runFamilyCheck({
+        scope: paths.length > 0 ? { kind: "paths", paths } : { kind: "all" },
+        ...options.config === void 0 ? {} : { configPath: options.config },
+        onNotice: notice
+      });
+      for (const check of run2.checks) {
+        if (check.status === "error") {
+          process.stderr.write(`${programName()} ${check.command} could not run: ${check.message}
+`);
+        }
+      }
+      const color = shouldColor({ noColor: !options.color, isTTY: process.stdout.isTTY });
+      const text = render(run2, options.format, color);
+      if (text.length > 0) process.stdout.write(`${text}
+`);
+      process.exitCode = exitCodeFor(run2);
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+function buildStatus() {
+  return new Command("status").description("Say what is set up here, and so what manni check runs").option("-c, --config <path>", "path to a manni config file").addOption(
+    new Option("-f, --format <format>", "output").choices(STATUS_FORMATS).default("pretty")
+  ).showHelpAfterError("(add --help for usage)").exitOverride().action(async (options) => {
+    const envelope = await readEnvelope();
+    const configOption = options.config === void 0 ? {} : { configPath: options.config };
+    if (envelope?.event === "SessionStart") {
+      try {
+        const report = await runStatus({ cwd: resolve5(envelope.cwd ?? process.cwd()), ...configOption });
+        const lines = report.domains.some((d) => d.status === "in-play") ? `
+
+${agentLines(report)}` : "";
+        process.stdout.write(`${renderStatus(report, "pretty")}${lines}
+`);
+        exportGeneratedBy(envelope);
+      } catch {
+      }
+      return;
+    }
+    try {
+      const report = await runStatus(configOption);
+      process.stdout.write(`${renderStatus(report, options.format)}
+`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+export {
+  buildCheck,
+  buildStatus
+};
+//# sourceMappingURL=cli-PYPX6O6E.js.map