@anyforge/control 0.12.0 → 0.13.1

package/dist/opencode-plugin.js

@@ -0,0 +1,567 @@
+// src/opencodePlugin/plugin.ts
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// src/opencodePlugin/exporter.ts
+var SCOPE = { name: "anyforge-opencode-plugin" };
+var MAX_BUFFERED_LOGS = 2e3;
+var LOGS_PER_EXPORT = 1e3;
+var TelemetryExporter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  logs = [];
+  usage = /* @__PURE__ */ new Map();
+  stopped = false;
+  sending = null;
+  addLogs(records) {
+    if (this.stopped || records.length === 0) return;
+    this.logs.push(...records);
+    const max = this.options.maxBufferedLogs ?? MAX_BUFFERED_LOGS;
+    if (this.logs.length > max) this.logs.splice(0, this.logs.length - max);
+  }
+  addUsage(readings) {
+    if (this.stopped) return;
+    for (const r of readings) {
+      const sum = this.usage.get(r.model) ?? { model: r.model, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: 0 };
+      sum.input += r.input;
+      sum.output += r.output;
+      sum.cacheRead += r.cacheRead;
+      sum.cacheWrite += r.cacheWrite;
+      sum.costUsd += r.costUsd;
+      this.usage.set(r.model, sum);
+    }
+  }
+  /** Has a key refusal stopped this exporter? */
+  get disabled() {
+    return this.stopped;
+  }
+  /** Send what is buffered. Never throws; concurrent calls share one send. */
+  flush(nowMs = Date.now()) {
+    if (!this.sending) this.sending = this.send(nowMs).finally(() => {
+      this.sending = null;
+    });
+    return this.sending;
+  }
+  async send(nowMs) {
+    if (this.stopped) return;
+    if (this.usage.size > 0) {
+      const usage = [...this.usage.values()];
+      this.usage = /* @__PURE__ */ new Map();
+      const status = await this.post("/api/otel/v1/metrics", metricsBody(this.options.resource, usage, nowMs));
+      if (!ok(status) && !this.stopped) this.addUsage(usage);
+    }
+    while (this.logs.length > 0 && !this.stopped) {
+      const batch = this.logs.slice(0, LOGS_PER_EXPORT);
+      const status = await this.post("/api/otel/v1/logs", logsBody(this.options.resource, batch));
+      if (!ok(status)) return;
+      this.logs.splice(0, batch.length);
+    }
+  }
+  async post(path, body) {
+    try {
+      const res = await this.options.fetch(`${this.options.endpoint}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${this.options.apiKey}` },
+        body: JSON.stringify(body)
+      });
+      if (res.status === 401 || res.status === 403) {
+        this.stopped = true;
+        this.logs = [];
+        this.usage = /* @__PURE__ */ new Map();
+      }
+      return res.status;
+    } catch {
+      return null;
+    }
+  }
+};
+function ok(status) {
+  return status !== null && status >= 200 && status < 300;
+}
+function logsBody(resource, records) {
+  return { resourceLogs: [{ resource: { attributes: resource }, scopeLogs: [{ scope: SCOPE, logRecords: records }] }] };
+}
+function metricsBody(resource, usage, nowMs) {
+  const time = `${Math.floor(nowMs)}000000`;
+  const model = (m) => ({ key: "model", value: { stringValue: m } });
+  const tokenPoints = usage.flatMap((u) => [
+    ["input", u.input],
+    ["output", u.output],
+    ["cacheRead", u.cacheRead],
+    ["cacheCreation", u.cacheWrite]
+  ].filter(([, n]) => n > 0).map(([type, n]) => ({
+    attributes: [{ key: "type", value: { stringValue: type } }, model(u.model)],
+    asInt: String(Math.round(n)),
+    timeUnixNano: time
+  })));
+  const costPoints = usage.filter((u) => u.costUsd > 0).map((u) => ({ attributes: [model(u.model)], asDouble: u.costUsd, timeUnixNano: time }));
+  const sum = (dataPoints) => ({ aggregationTemporality: 1, isMonotonic: true, dataPoints });
+  return {
+    resourceMetrics: [{
+      resource: { attributes: resource },
+      scopeMetrics: [{
+        scope: SCOPE,
+        metrics: [
+          ...tokenPoints.length ? [{ name: "opencode.token.usage", unit: "tokens", sum: sum(tokenPoints) }] : [],
+          ...costPoints.length ? [{ name: "opencode.cost.usage", unit: "USD", sum: sum(costPoints) }] : []
+        ]
+      }]
+    }]
+  };
+}
+
+// src/opencodePlugin/translate.ts
+var EMPTY = { logs: [], usage: [] };
+var MAX_REMEMBERED = 5e3;
+var Remembered = class {
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.map.get(key);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  set(key, value) {
+    this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > MAX_REMEMBERED) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) this.map.delete(oldest);
+    }
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function attr(key, value) {
+  if (typeof value === "boolean") return { key, value: { boolValue: value } };
+  if (typeof value === "number") return Number.isInteger(value) ? { key, value: { intValue: String(value) } } : { key, value: { doubleValue: value } };
+  return { key, value: { stringValue: value } };
+}
+function sanitize(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function mcpPrefixesOf(server2) {
+  return [.../* @__PURE__ */ new Set([`${sanitize(server2)}_`, `${server2}_`, `${server2}.`, `${server2}/`, `${server2}:`])];
+}
+var BUILTIN_TOOLS = /* @__PURE__ */ new Set([
+  "bash",
+  "read",
+  "write",
+  "edit",
+  "multiedit",
+  "patch",
+  "apply_patch",
+  "glob",
+  "grep",
+  "list",
+  "ls",
+  "webfetch",
+  "websearch",
+  "codesearch",
+  "todowrite",
+  "todoread",
+  "task",
+  "skill",
+  "lsp",
+  "question",
+  "batch",
+  "invalid",
+  "external_directory",
+  "doom_loop"
+]);
+var UNNAMED_TOOL = "other_tool";
+var STOPPED_ERROR = /abort|cancel|interrupt/i;
+var TOOL_NAME = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,99}$/;
+var OpencodeTelemetry = class {
+  constructor(options) {
+    this.options = options;
+    this.setMcpServers(options.mcpServers);
+  }
+  options;
+  mcpPrefixes = [];
+  models = new Remembered();
+  callTools = new Remembered();
+  permissionTools = new Remembered();
+  reported = new Remembered();
+  toolStarts = new Remembered();
+  proxiedProviders = /* @__PURE__ */ new Set();
+  /** The configured MCP servers, which V2 reports after the plugin has started. */
+  setMcpServers(servers) {
+    this.mcpPrefixes = servers.flatMap((server2) => mcpPrefixesOf(server2).map((prefix) => ({ server: server2, prefix }))).sort((a, b) => b.prefix.length - a.prefix.length);
+  }
+  /** `chat.message`: the member sent a prompt. Its text is never read. */
+  prompt(nowMs) {
+    return { logs: [this.record("user_prompt", nowMs, [])], usage: [] };
+  }
+  /**
+   * `chat.params`: the provider and the base URL this call goes to. A provider
+   * pointed at the AnyForge proxy is remembered, and its calls send no tokens.
+   */
+  provider(providerID, baseURL) {
+    const id = str(providerID);
+    const url = str(baseURL);
+    if (!id || !url || !this.options.anyforgeHost) return;
+    let host;
+    try {
+      host = new URL(url).host;
+    } catch {
+      return;
+    }
+    if (host === this.options.anyforgeHost) this.proxiedProviders.add(id);
+    else this.proxiedProviders.delete(id);
+  }
+  /** One OpenCode bus event (the plugin's `event` hook). */
+  event(event, nowMs) {
+    if (!isRecord(event) || !isRecord(event.properties)) return EMPTY;
+    const props = event.properties;
+    switch (event.type) {
+      case "message.updated":
+        return this.message(props.info, nowMs);
+      case "message.part.updated":
+        return this.part(props.part, nowMs);
+      case "permission.updated":
+        this.notePermission(str(props.id), str(props.callID), str(props.type));
+        return EMPTY;
+      case "permission.asked":
+        this.notePermission(str(props.id), isRecord(props.tool) ? str(props.tool.callID) : void 0, str(props.permission));
+        return EMPTY;
+      case "permission.replied":
+        return this.decision(str(props.requestID) ?? str(props.permissionID), str(props.reply) ?? str(props.response), nowMs);
+      default:
+        return EMPTY;
+    }
+  }
+  message(info, nowMs) {
+    if (!isRecord(info) || info.role !== "assistant") return EMPTY;
+    const id = str(info.id);
+    const modelID = str(info.modelID);
+    const providerID = str(info.providerID);
+    if (!id) return EMPTY;
+    if (modelID && providerID) this.models.set(id, { modelID, providerID });
+    const error = isRecord(info.error) ? info.error : null;
+    if (!error || error.name === "MessageAbortedError" || this.reported.has(`error:${id}`)) return EMPTY;
+    this.reported.set(`error:${id}`, true);
+    return { logs: [this.record("api_error", nowMs, modelID ? [attr("model", modelID)] : [])], usage: [] };
+  }
+  part(part, nowMs) {
+    if (!isRecord(part)) return EMPTY;
+    const id = str(part.id);
+    if (!id) return EMPTY;
+    if (part.type === "step-finish") return this.step(part, id, nowMs);
+    if (part.type === "tool") return this.tool(part, id, nowMs);
+    return EMPTY;
+  }
+  /** One finished model call (V1 `step-finish` part). */
+  step(part, id, nowMs) {
+    return this.modelCall(`step:${id}`, str(part.messageID), part.tokens, part.cost, "api_request", nowMs);
+  }
+  /**
+   * One model call: an `api_request` (or `api_error`) and its tokens, unless
+   * the AnyForge proxy already metered them. Reported once per key.
+   */
+  modelCall(key, messageID, rawTokens, cost, event, nowMs) {
+    if (this.reported.has(key)) return EMPTY;
+    this.reported.set(key, true);
+    const model = this.models.get(messageID ?? "");
+    const logs = [this.record(event, nowMs, model ? [attr("model", model.modelID)] : [])];
+    return { logs, usage: this.usage(model, rawTokens, cost) };
+  }
+  usage(model, rawTokens, cost) {
+    if (model && this.proxiedProviders.has(model.providerID)) return [];
+    const tokens = isRecord(rawTokens) ? rawTokens : {};
+    const cache = isRecord(tokens.cache) ? tokens.cache : {};
+    const reading = {
+      model: model?.modelID ?? "unknown",
+      input: num(tokens.input),
+      // Reasoning tokens are billed as output.
+      output: num(tokens.output) + num(tokens.reasoning),
+      cacheRead: num(cache.read),
+      cacheWrite: num(cache.write),
+      costUsd: num(cost)
+    };
+    const any = reading.input + reading.output + reading.cacheRead + reading.cacheWrite + reading.costUsd > 0;
+    return any ? [reading] : [];
+  }
+  // ── OpenCode V2 ──────────────────────────────────────────────────────────
+  /** One V2 session or permission event, `{ id, type, data }`. */
+  eventV2(event, nowMs) {
+    if (!isRecord(event) || !isRecord(event.data)) return EMPTY;
+    const data = event.data;
+    const eventId = str(event.id);
+    switch (event.type) {
+      case "session.inbox.enqueued": {
+        const inboxID = str(data.inboxID);
+        if (!isRecord(data.item) || data.item.type !== "user" || !inboxID || this.reported.has(`prompt:${inboxID}`)) return EMPTY;
+        this.reported.set(`prompt:${inboxID}`, true);
+        return this.prompt(nowMs);
+      }
+      case "session.step.started": {
+        const messageID = str(data.assistantMessageID);
+        const model = isRecord(data.model) ? data.model : {};
+        const modelID = str(model.id);
+        const providerID = str(model.providerID);
+        if (messageID && modelID && providerID) this.models.set(messageID, { modelID, providerID });
+        return EMPTY;
+      }
+      case "session.step.ended":
+        if (!eventId) return EMPTY;
+        return this.modelCall(`step2:${eventId}`, str(data.assistantMessageID), data.tokens, data.cost, "api_request", nowMs);
+      case "session.step.failed": {
+        if (!eventId) return EMPTY;
+        const error = isRecord(data.error) ? data.error : {};
+        if (STOPPED_ERROR.test(str(error.type) ?? "")) {
+          this.reported.set(`step2:${eventId}`, true);
+          return { logs: [], usage: this.usage(this.models.get(str(data.assistantMessageID) ?? ""), data.tokens, data.cost) };
+        }
+        return this.modelCall(`step2:${eventId}`, str(data.assistantMessageID), data.tokens, data.cost, "api_error", nowMs);
+      }
+      case "session.skill.activated": {
+        if (!eventId || this.reported.has(`skill:${eventId}`)) return EMPTY;
+        this.reported.set(`skill:${eventId}`, true);
+        return { logs: [this.record("skill_activated", nowMs, [attr("skill.name", this.skillName({ name: data.name }))])], usage: [] };
+      }
+      case "permission.asked": {
+        const source = isRecord(data.source) ? data.source : {};
+        this.notePermission(str(data.id), str(source.id), str(data.action));
+        return EMPTY;
+      }
+      case "permission.replied":
+        return this.decision(str(data.requestID), str(data.reply), nowMs);
+      default:
+        return EMPTY;
+    }
+  }
+  /** V2 `tool` hook `execute.before`: remember the call's tool and start time. */
+  toolStarted(callID, tool, nowMs) {
+    const id = str(callID);
+    const name = str(tool);
+    if (!id || !name) return;
+    this.callTools.set(id, name);
+    this.toolStarts.set(id, nowMs);
+  }
+  /** V2 `tool` hook `execute.after`: one finished call. V2 reports skills as their own event. */
+  toolEnded(callID, tool, status, nowMs) {
+    const id = str(callID);
+    const name = str(tool) ?? (id ? this.callTools.get(id) : void 0);
+    if (!id || !name || status !== "completed" && status !== "error") return EMPTY;
+    if (this.reported.has(`tool2:${id}`)) return EMPTY;
+    this.reported.set(`tool2:${id}`, true);
+    const started = this.toolStarts.get(id);
+    const duration = started === void 0 ? 0 : nowMs - started;
+    return {
+      logs: [this.record("tool_result", nowMs, [
+        ...this.toolAttributes(name),
+        attr("success", status === "completed"),
+        ...duration > 0 && duration < 864e5 ? [attr("duration_ms", Math.round(duration))] : []
+      ])],
+      usage: []
+    };
+  }
+  tool(part, id, nowMs) {
+    const tool = str(part.tool);
+    const state = isRecord(part.state) ? part.state : null;
+    if (!tool || !state) return EMPTY;
+    const callID = str(part.callID);
+    if (callID) this.callTools.set(callID, tool);
+    if (state.status !== "completed" && state.status !== "error") return EMPTY;
+    if (this.reported.has(`tool:${id}`)) return EMPTY;
+    this.reported.set(`tool:${id}`, true);
+    const time = isRecord(state.time) ? state.time : {};
+    const duration = num(time.end) - num(time.start);
+    const attributes = [
+      ...this.toolAttributes(tool),
+      attr("success", state.status === "completed"),
+      ...duration > 0 && duration < 864e5 ? [attr("duration_ms", Math.round(duration))] : []
+    ];
+    const logs = [this.record("tool_result", nowMs, attributes)];
+    if (tool === "skill") logs.push(this.record("skill_activated", nowMs, [attr("skill.name", this.skillName(state.input))]));
+    return { logs, usage: [] };
+  }
+  notePermission(id, callID, permission) {
+    if (!id) return;
+    const tool = (callID && this.callTools.get(callID)) ?? permission;
+    if (tool) this.permissionTools.set(id, tool);
+  }
+  /** A person answered a permission prompt. Rules that allow or deny on their own send no event. */
+  decision(id, reply, nowMs) {
+    if (!id || !reply || this.reported.has(`decision:${id}`)) return EMPTY;
+    const outcome = reply === "once" ? { decision: "accept", source: "user_temporary" } : reply === "always" ? { decision: "accept", source: "user_permanent" } : reply === "reject" ? { decision: "reject", source: "user_reject" } : null;
+    if (!outcome) return EMPTY;
+    this.reported.set(`decision:${id}`, true);
+    const tool = this.permissionTools.get(id);
+    return {
+      logs: [this.record("tool_decision", nowMs, [
+        ...tool ? this.toolAttributes(tool) : [],
+        attr("decision", outcome.decision),
+        attr("source", outcome.source)
+      ])],
+      usage: []
+    };
+  }
+  /** `tool_name` and `tool_source`, in the form Claude Code uses for an MCP tool. */
+  toolAttributes(tool) {
+    const mcp = this.mcpPrefixes.find((m) => tool.startsWith(m.prefix) && tool.length > m.prefix.length);
+    if (mcp) {
+      const name = this.options.sendNames ? `mcp__${mcp.server}__${tool.slice(mcp.prefix.length)}` : "mcp_tool";
+      return [attr("tool_name", TOOL_NAME.test(name) ? name : "mcp_tool"), attr("tool_source", "mcp")];
+    }
+    const named = this.options.sendNames ? TOOL_NAME.test(tool) : BUILTIN_TOOLS.has(tool);
+    return [attr("tool_name", named ? tool : UNNAMED_TOOL), attr("tool_source", "builtin")];
+  }
+  skillName(input) {
+    const name = isRecord(input) ? str(input.name) : void 0;
+    return this.options.sendNames && name && TOOL_NAME.test(name) ? name : "custom_skill";
+  }
+  record(event, nowMs, attributes) {
+    const nano = `${Math.floor(nowMs)}000000`;
+    return {
+      timeUnixNano: nano,
+      observedTimeUnixNano: nano,
+      body: { stringValue: `opencode.${event}` },
+      attributes: [attr("event.name", event), attr("event.timestamp", new Date(nowMs).toISOString()), ...attributes]
+    };
+  }
+};
+
+// src/opencodePlugin/plugin.ts
+var FLUSH_INTERVAL_MS = 1e4;
+async function readJson(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function mcpServerNames(input) {
+  try {
+    const res = await input.client?.config?.get?.();
+    const config = res && typeof res === "object" && "data" in res ? res.data : res;
+    const mcp = config?.mcp;
+    if (!mcp || typeof mcp !== "object") return [];
+    const entries = mcp;
+    const servers = entries.servers && typeof entries.servers === "object" ? Object.keys(entries.servers) : [];
+    const legacy = Object.keys(entries).filter((k) => k !== "servers" && k !== "timeout" && typeof entries[k] === "object");
+    return [.../* @__PURE__ */ new Set([...servers, ...legacy])];
+  } catch {
+    return [];
+  }
+}
+async function start(mcpServers) {
+  const anyforgeDir = join(homedir(), ".anyforge");
+  const creds = await readJson(join(anyforgeDir, "credentials"));
+  const apiKey = typeof creds?.apiKey === "string" ? creds.apiKey : null;
+  const endpoint = typeof creds?.endpoint === "string" ? creds.endpoint.replace(/\/+$/, "") : null;
+  if (!apiKey || !endpoint) return null;
+  let anyforgeHost;
+  try {
+    anyforgeHost = new URL(endpoint).host;
+  } catch {
+    return null;
+  }
+  const settings = await readJson(join(anyforgeDir, "opencode-telemetry.json"));
+  const telemetry = new OpencodeTelemetry({ sendNames: settings?.sendNames === true, mcpServers, anyforgeHost });
+  const exporter = new TelemetryExporter({
+    endpoint,
+    apiKey,
+    fetch: (async (url, init) => ({ status: (await fetch(url, init)).status })),
+    resource: [{ key: "service.name", value: { stringValue: "opencode" } }]
+  });
+  const timer = setInterval(() => {
+    void exporter.flush();
+  }, FLUSH_INTERVAL_MS);
+  timer.unref?.();
+  return {
+    telemetry,
+    exporter,
+    take: (t) => {
+      exporter.addLogs(t.logs);
+      exporter.addUsage(t.usage);
+    },
+    stop: async () => {
+      clearInterval(timer);
+      await exporter.flush();
+    }
+  };
+}
+function quietly(step) {
+  try {
+    step();
+  } catch {
+  }
+}
+async function server(input) {
+  const run = await start(await mcpServerNames(input));
+  if (!run) return {};
+  const { telemetry, take, exporter } = run;
+  return {
+    "chat.message": async () => quietly(() => take(telemetry.prompt(Date.now()))),
+    "chat.params": async (params) => quietly(() => telemetry.provider(params?.provider?.info?.id, params?.provider?.options?.baseURL)),
+    event: async ({ event }) => quietly(() => {
+      take(telemetry.event(event, Date.now()));
+      if (event?.type === "session.idle") void exporter.flush();
+    }),
+    dispose: () => run.stop()
+  };
+}
+var V2_EVENTS = [
+  "session.inbox.enqueued",
+  "session.step.started",
+  "session.step.ended",
+  "session.step.failed",
+  "session.skill.activated",
+  "session.execution.succeeded",
+  "session.execution.failed",
+  "permission.asked",
+  "permission.replied"
+];
+async function setup(ctx) {
+  const run = await start([]);
+  if (!run) return;
+  const { telemetry, take, exporter } = run;
+  const registrations = [];
+  const register = async (registering) => {
+    try {
+      registrations.push(await registering());
+    } catch {
+    }
+  };
+  await register(() => ctx.mcp.transform((editor) => quietly(() => telemetry.setMcpServers(editor.list().map(([name]) => name)))));
+  await register(() => ctx.session.hook("model.request", (input) => quietly(() => telemetry.provider(input?.model?.providerID, input?.baseURL))));
+  await register(() => ctx.tool.hook("execute.before", (input) => quietly(() => telemetry.toolStarted(input?.id, input?.tool, Date.now()))));
+  await register(() => ctx.tool.hook("execute.after", (input) => quietly(() => take(telemetry.toolEnded(input?.id, input?.tool, input?.status, Date.now())))));
+  const abort = new AbortController();
+  void (async () => {
+    try {
+      for await (const event of ctx.event.subscribe({ types: V2_EVENTS, signal: abort.signal })) {
+        quietly(() => {
+          take(telemetry.eventV2(event, Date.now()));
+          const type = event?.type;
+          if (type === "session.execution.succeeded" || type === "session.execution.failed") void exporter.flush();
+        });
+      }
+    } catch {
+    }
+  })();
+  return async () => {
+    abort.abort();
+    await Promise.all(registrations.map((r) => r.dispose().catch(() => {
+    })));
+    await run.stop();
+  };
+}
+var AnyforgeTelemetry = { id: "anyforge-telemetry", setup, server };
+var plugin_default = AnyforgeTelemetry;
+export {
+  plugin_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyforge/control",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "description": "AnyForge CLI — hosted Oracle conversations, a governed LLM proxy, and a scriptable client for approvals, crews, work items and workflows.",
   "license": "Apache-2.0",
   "homepage": "https://anyforge.ai",
@@ -23,7 +23,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "esbuild src/cli.ts --bundle --minify --platform=node --format=esm --outfile=dist/cli.js --packages=external && chmod +x dist/cli.js",
+    "build": "esbuild src/cli.ts --bundle --minify --platform=node --format=esm --outfile=dist/cli.js --packages=external && chmod +x dist/cli.js && esbuild src/opencodePlugin/plugin.ts --bundle --platform=node --format=esm --outfile=dist/opencode-plugin.js",
     "type-check": "tsc --noEmit",
     "test": "npm run build && node scripts/test.mjs",
     "dev": "tsx src/cli.ts",