@wirecat/mail-cli 0.0.0-stage → 0.1.0

package/dist/bundle/chunk-4E7BN3TC.js

@@ -0,0 +1,122 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  unit
+} from "./chunk-Z34ICZA3.js";
+import {
+  CliError
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/embeddings/remote.js
+import { setTimeout } from "node:timers/promises";
+var OPENAI_URL = "https://api.openai.com/v1";
+var OPENAI_MODELS = {
+  "text-embedding-3-small": { dims: 1536, perMillion: 0.02 },
+  "text-embedding-3-large": { dims: 3072, perMillion: 0.13 }
+};
+var DEFAULT_OPENAI_MODEL = "text-embedding-3-small";
+var PER_REQUEST = 256;
+var LOCAL = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+var isLocal = /* @__PURE__ */ __name((baseUrl) => LOCAL.has(new URL(baseUrl).hostname), "isLocal");
+var remoteModel = /* @__PURE__ */ __name(({ model = DEFAULT_OPENAI_MODEL, baseUrl, dims }) => {
+  const known = baseUrl === void 0 ? OPENAI_MODELS[model] : void 0;
+  if (baseUrl === void 0 && !known) {
+    throw new CliError("validation_error", `OpenAI has no embedding model ${model} here \u2014 one of: ${Object.keys(OPENAI_MODELS).join(", ")}; another server takes --base-url`);
+  }
+  const size = dims ?? known?.dims;
+  if (size === void 0)
+    throw new CliError("validation_error", "with --base-url, say the vector size with --dims");
+  return {
+    provider: baseUrl === void 0 ? "openai" : `url:${new URL(baseUrl).host}`,
+    model,
+    dims: size,
+    baseUrl: baseUrl ?? OPENAI_URL,
+    shorten: known !== void 0 && size !== known.dims,
+    ...known ? { price: { perMillion: known.perMillion, read: "2026-10-02" } } : {}
+  };
+}, "remoteModel");
+var remoteKey = /* @__PURE__ */ __name(({ provider, model, dims }) => `${provider}:${model}:${dims}`, "remoteKey");
+var openRemote = /* @__PURE__ */ __name((remote, apiKey, { concurrency = 4, fetch: post = fetch, tries = 5 } = {}) => {
+  const request = /* @__PURE__ */ __name(async (input) => {
+    for (let attempt = 1; ; attempt++) {
+      let response;
+      try {
+        response = await post(`${remote.baseUrl.replace(/\/$/, "")}/embeddings`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...apiKey ? { authorization: `Bearer ${apiKey}` } : {}
+          },
+          body: JSON.stringify({
+            model: remote.model,
+            input,
+            encoding_format: "float",
+            ...remote.shorten ? { dimensions: remote.dims } : {}
+          })
+        });
+      } catch {
+        if (attempt >= tries)
+          throw new CliError("network_error", `${remote.provider} could not be reached`);
+        await setTimeout(1e3 * attempt);
+        continue;
+      }
+      if (response.ok) {
+        const body = await response.json();
+        const data = [...body.data ?? []].sort((a, b) => a.index - b.index);
+        if (data.length !== input.length || data.some(({ embedding }) => embedding.length !== remote.dims)) {
+          throw new CliError("invalid_response", `${remote.provider} answered with vectors of another number or size than ${input.length} \xD7 ${remote.dims}`);
+        }
+        return data.map(({ embedding }) => unit(Float32Array.from(embedding)));
+      }
+      const code = await errorCode(response);
+      if (response.status === 401 || response.status === 403) {
+        throw new CliError("authentication_error", `${remote.provider} refused the key (HTTP ${response.status}${code}) \u2014 set it again with \`models keys set\``);
+      }
+      const again = response.status === 429 || response.status >= 500;
+      if (!again || attempt >= tries) {
+        throw new CliError(response.status === 429 ? "rate_limited" : "provider_error", `${remote.provider} answered HTTP ${response.status}${code}`);
+      }
+      const wait = Number(response.headers.get("retry-after"));
+      await setTimeout(Number.isFinite(wait) && wait > 0 ? wait * 1e3 : 1e3 * 2 ** attempt);
+    }
+  }, "request");
+  return {
+    model: { id: remote.model, dims: remote.dims },
+    embed: /* @__PURE__ */ __name(async (texts) => {
+      const parts = [];
+      for (let start = 0; start < texts.length; start += PER_REQUEST)
+        parts.push(texts.slice(start, start + PER_REQUEST));
+      const results = new Array(parts.length);
+      let next = 0;
+      await Promise.all(Array.from({ length: Math.min(concurrency, parts.length) }, async () => {
+        for (let index = next++; index < parts.length; index = next++)
+          results[index] = await request(parts[index]);
+      }));
+      return results.flat();
+    }, "embed"),
+    close: /* @__PURE__ */ __name(async () => {
+    }, "close")
+  };
+}, "openRemote");
+var errorCode = /* @__PURE__ */ __name(async (response) => {
+  try {
+    const body = await response.json();
+    const code = body.error?.code ?? body.error?.type;
+    return typeof code === "string" && /^[\w.-]{1,64}$/.test(code) ? `, ${code}` : "";
+  } catch {
+    return "";
+  }
+}, "errorCode");
+
+export {
+  OPENAI_URL,
+  OPENAI_MODELS,
+  DEFAULT_OPENAI_MODEL,
+  isLocal,
+  remoteModel,
+  remoteKey,
+  openRemote
+};

package/dist/bundle/chunk-4FEMINO2.js

@@ -0,0 +1,409 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError,
+  singleLine
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/domain/locator.js
+var SCHEME = "msg:";
+var formatLocator = /* @__PURE__ */ __name(({ provider, account, chat, message }) => SCHEME + [provider, account, chat, message].map(encodeURIComponent).join("/"), "formatLocator");
+var isLocator = /* @__PURE__ */ __name((reference) => reference.trim().startsWith(SCHEME), "isLocator");
+var parseLocator = /* @__PURE__ */ __name((reference) => {
+  const trimmed = reference.trim();
+  const parts2 = trimmed.startsWith(SCHEME) ? trimmed.slice(SCHEME.length).split("/") : [];
+  if (parts2.length !== 4 || parts2.some((part) => part === "")) {
+    throw new CliError("validation_error", `"${singleLine(reference)}" is not a message locator \u2014 expected msg:<provider>/<account>/<chat>/<message>`);
+  }
+  const [provider, account, chat, message] = parts2.map(decodeURIComponent);
+  return { provider, account, chat, message };
+}, "parseLocator");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/domain/references.js
+var SIMPLE_REFERENCES = [
+  "note",
+  "document",
+  "person",
+  "organization",
+  "project",
+  "task",
+  "memory",
+  "fact",
+  "bot",
+  "entity"
+];
+var parts = /* @__PURE__ */ __name((rest, count, reference, shape) => {
+  const split = rest.split("/");
+  if (split.length !== count || split.some((part) => part === ""))
+    throw new CliError("validation_error", `"${singleLine(reference)}" is not a reference \u2014 expected ${shape}`);
+  return split.map(decodeURIComponent);
+}, "parts");
+var formatReference = /* @__PURE__ */ __name((reference) => {
+  switch (reference.type) {
+    case "message":
+      return formatLocator(reference);
+    case "chat":
+      return `chat:${[reference.provider, reference.account, reference.chat].map(encodeURIComponent).join("/")}`;
+    case "contact":
+      return `contact:${[reference.provider, reference.id].map(encodeURIComponent).join("/")}`;
+    case "folder":
+      return reference.path === null ? `folder:${encodeURIComponent(reference.id)}` : `folder:${encodeURIComponent(reference.id)}/${encodeURIComponent(reference.path)}`;
+    default:
+      return `${reference.type}:${reference.id}`;
+  }
+}, "formatReference");
+var parseReference = /* @__PURE__ */ __name((text) => {
+  const reference = text.trim();
+  const colon = reference.indexOf(":");
+  const prefix = colon < 0 ? "" : reference.slice(0, colon);
+  const rest = reference.slice(colon + 1);
+  switch (prefix) {
+    case "msg":
+      return { type: "message", ...parseLocator(reference) };
+    case "chat": {
+      const [provider, account, chat] = parts(rest, 3, reference, "chat:<provider>/<account>/<chat>");
+      return { type: "chat", provider, account, chat };
+    }
+    case "contact": {
+      const [provider, id] = parts(rest, 2, reference, "contact:<provider>/<id>");
+      return { type: "contact", provider, id };
+    }
+    case "folder": {
+      const slash = rest.indexOf("/");
+      const id = decodeURIComponent(slash < 0 ? rest : rest.slice(0, slash));
+      const path = slash < 0 ? null : folderPath(decodeURIComponent(rest.slice(slash + 1)));
+      if (!id.trim() || path === "")
+        throw new CliError("validation_error", `"${singleLine(reference)}" is not a reference \u2014 expected folder:<id>[/<path>]`);
+      return { type: "folder", id, path };
+    }
+    default:
+      if (SIMPLE_REFERENCES.includes(prefix)) {
+        if (!rest.trim())
+          throw new CliError("validation_error", `"${singleLine(reference)}" names no ${prefix}`);
+        return { type: prefix, id: rest };
+      }
+      throw new CliError("validation_error", `"${singleLine(reference)}" is not a reference \u2014 expected msg:, chat:, contact:, folder:, ${SIMPLE_REFERENCES.filter((one) => one !== "entity").join(":, ")}:`);
+  }
+}, "parseReference");
+var folderPath = /* @__PURE__ */ __name((path) => {
+  const clean = path.split("/").filter((part) => part !== "" && part !== ".").join("/");
+  return clean === "" ? path.trim() === "" ? "" : null : clean;
+}, "folderPath");
+var canonicalReference = /* @__PURE__ */ __name((text) => formatReference(parseReference(text)), "canonicalReference");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/domain/providers.js
+var KINDS = ["messages", "mail", "notes", "documents", "meetings", "events"];
+var PROVIDERS = [
+  { name: "telegram", kind: "messages", aliases: ["tg"] },
+  { name: "telegram-bot", kind: "messages", aliases: ["tg-bot"] },
+  { name: "max", kind: "messages", aliases: [] },
+  { name: "max-bot", kind: "messages", aliases: [] },
+  { name: "whatsapp", kind: "messages", aliases: ["wa"] },
+  { name: "whatsapp-bot", kind: "messages", aliases: ["wa-bot"] },
+  { name: "email", kind: "mail", aliases: [] },
+  { name: "notes", kind: "notes", aliases: [] },
+  { name: "local", kind: "notes", aliases: [] },
+  { name: "obsidian", kind: "notes", aliases: [] },
+  { name: "zoom", kind: "meetings", aliases: [] }
+];
+var FOLDER_PROVIDERS = ["local", "obsidian", "folder"];
+var isFolderProvider = /* @__PURE__ */ __name((provider) => FOLDER_PROVIDERS.includes(provider), "isFolderProvider");
+var folderProviderSql = /* @__PURE__ */ __name((column = "provider") => `${column} IN (${FOLDER_PROVIDERS.map((name) => `'${name}'`).join(", ")})`, "folderProviderSql");
+var folderProviderOf = /* @__PURE__ */ __name((format) => format === "markdown" ? "local" : "obsidian", "folderProviderOf");
+var DOCUMENT_ACCOUNT_PROVIDERS = ["google-drive"];
+var isDocumentAccountProvider = /* @__PURE__ */ __name((provider) => DOCUMENT_ACCOUNT_PROVIDERS.includes(provider), "isDocumentAccountProvider");
+var filesAccountSql = /* @__PURE__ */ __name((column = "provider") => `${column} IN (${[...FOLDER_PROVIDERS, ...DOCUMENT_ACCOUNT_PROVIDERS].map((name) => `'${name}'`).join(", ")})`, "filesAccountSql");
+var INTERNAL_NOTES = "internal";
+var UNKNOWN_PROVIDER = "unknown provider \u2014 run its CLI once";
+var WORD = /^[a-z0-9][a-z0-9_-]*$/;
+var invalid = /* @__PURE__ */ __name((message) => {
+  throw new CliError("validation_error", message);
+}, "invalid");
+var wordOf = /* @__PURE__ */ __name((value, what) => typeof value === "string" && WORD.test(value) ? value : invalid(`${what} is lowercase letters, digits, - and _ \u2014 not ${JSON.stringify(value)}`), "wordOf");
+var providerEntryOf = /* @__PURE__ */ __name((value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return invalid("a provider entry is an object");
+  const { name, kind, aliases = [], command } = value;
+  const named = wordOf(name, "a provider's name");
+  if (typeof kind !== "string" || !KINDS.includes(kind))
+    invalid(`provider ${named}'s kind is one of ${KINDS.join(", ")} \u2014 not ${JSON.stringify(kind)}`);
+  if (!Array.isArray(aliases))
+    invalid(`provider ${named}'s aliases are a list`);
+  return {
+    name: named,
+    kind,
+    aliases: [...new Set(aliases.map((alias) => wordOf(alias, `an alias of ${named}`)))],
+    ...command === void 0 ? {} : { command: wordOf(command, `the command of ${named}`) }
+  };
+}, "providerEntryOf");
+var describe = /* @__PURE__ */ __name(({ name, kind, command }) => `${name} (${kind}${command ? `, from ${command}` : ""})`, "describe");
+var wordsOf = /* @__PURE__ */ __name(({ name, aliases }) => [name, ...aliases], "wordsOf");
+var joined = /* @__PURE__ */ __name((known, entry) => {
+  const same = known.find(({ name }) => name === entry.name);
+  if (same && same.kind !== entry.kind)
+    invalid(`two provider entries disagree on the kind: ${describe(same)} and ${describe(entry)}`);
+  const merged = same ? {
+    ...same,
+    aliases: [.../* @__PURE__ */ new Set([...same.aliases, ...entry.aliases])],
+    ...entry.command ? { command: entry.command } : {}
+  } : entry;
+  const others = known.filter((one) => one !== same);
+  for (const word of wordsOf(merged)) {
+    const owner = others.find((one) => wordsOf(one).includes(word));
+    if (owner)
+      invalid(`"${word}" names two providers: ${describe(owner)} and ${describe(merged)}`);
+  }
+  return same ? known.map((one) => one === same ? merged : one) : [...known, merged];
+}, "joined");
+var registry = PROVIDERS;
+var providers = /* @__PURE__ */ __name(() => registry, "providers");
+var useProviders = /* @__PURE__ */ __name((entries) => {
+  registry = entries.map(providerEntryOf).reduce(joined, PROVIDERS);
+}, "useProviders");
+var useStoredProviders = /* @__PURE__ */ __name((entries) => {
+  const left = [];
+  registry = entries.reduce((known, entry) => {
+    try {
+      return joined(known, providerEntryOf(entry));
+    } catch (error) {
+      if (!(error instanceof CliError))
+        throw error;
+      left.push(entry);
+      return known;
+    }
+  }, PROVIDERS);
+  return left;
+}, "useStoredProviders");
+var addProvider = /* @__PURE__ */ __name((entry) => {
+  registry = joined(registry, providerEntryOf(entry));
+}, "addProvider");
+var isKind = /* @__PURE__ */ __name((word) => KINDS.includes(word.toLowerCase()), "isKind");
+var providerNamed = /* @__PURE__ */ __name((word) => {
+  const wanted = word.toLowerCase();
+  return registry.find((entry) => wordsOf(entry).includes(wanted));
+}, "providerNamed");
+var kindIn = /* @__PURE__ */ __name((provider) => isFolderProvider(provider) ? "notes" : registry.find(({ name }) => name === provider)?.kind, "kindIn");
+var kindOf = /* @__PURE__ */ __name((provider) => kindIn(provider) ?? "messages", "kindOf");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/domain/counters.js
+var COUNTER_FIELDS = ["views", "reactions", "comments"];
+var validCounter = /* @__PURE__ */ __name((value) => typeof value === "number" && Number.isFinite(value) && value >= 0, "validCounter");
+var counterValue = /* @__PURE__ */ __name((message, field) => {
+  const value = field === "reactions" ? message.reactions?.total : message.providerMetadata?.[field];
+  return validCounter(value) ? value : null;
+}, "counterValue");
+var counterObservationTime = /* @__PURE__ */ __name((observation, now) => {
+  const at = Date.parse(observation.observedAt);
+  if (!validCounter(observation.value) || !Number.isSafeInteger(at) || at < 0 || at > now || !["remote_fetch", "remote_update"].includes(observation.source))
+    throw new CliError("validation_error", "counter observation needs a valid value, source and nonfuture observation time");
+  if (observation.reactions && (!validCounter(observation.reactions.total) || observation.reactions.total !== observation.value))
+    throw new CliError("validation_error", "reaction observation payload and total disagree");
+  return at;
+}, "counterObservationTime");
+var observedCounters = /* @__PURE__ */ __name((message, observedAt, fields, source = "remote_fetch") => {
+  const observations = {};
+  for (const field of fields) {
+    const value = counterValue(message, field);
+    if (value !== null)
+      observations[field] = {
+        value,
+        observedAt,
+        source,
+        ...field === "reactions" && message.reactions ? { reactions: message.reactions } : {}
+      };
+  }
+  return { ...message, counterObservations: observations };
+}, "observedCounters");
+var counterFreshness = /* @__PURE__ */ __name((states) => {
+  if (!states.length || states.every((one) => one.freshness === "unknown"))
+    return "unknown";
+  if (states.some((one) => one.freshness === "unknown"))
+    return "partial";
+  return states.some((one) => one.freshness === "stale") ? "stale" : "fresh";
+}, "counterFreshness");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/domain/rankings-options.js
+var MESSAGE_MEASURES = ["views", "reactions", "forwards", "comments", "replies", "thread-size"];
+var AUTHOR_MEASURES = [
+  "messages",
+  "words",
+  "reactions",
+  "replies",
+  "answers",
+  "answer-time",
+  "threads",
+  "active-days"
+];
+var CONTEXT = /* @__PURE__ */ new Set([
+  "replies",
+  "replies-from-others",
+  "replies-from-others-per-message",
+  "thread-size",
+  "threads",
+  "answers",
+  "answer-time"
+]);
+var needsRankingContext = /* @__PURE__ */ __name((options) => options.components.some((name) => CONTEXT.has(name)), "needsRankingContext");
+var presets = {
+  helpful: { answers: 0.5, "replies-from-others": 0.25, reactions: 0.25 },
+  active: { "active-days": 0.6, messages: 0.4 },
+  engaging: { "reactions-per-message": 0.5, "replies-from-others-per-message": 0.5 }
+};
+function invalid2(message) {
+  throw new CliError("validation_error", message, { reason: "ranking.invalid" });
+}
+__name(invalid2, "invalid");
+var rankingOptions = /* @__PURE__ */ __name((target, input) => {
+  const measures = target === "messages" ? MESSAGE_MEASURES : AUTHOR_MEASURES;
+  const { measure, score, weights: given, minMessages } = input;
+  const messageKind = input.messageKind ?? "all";
+  if (!["all", "posts", "comments"].includes(messageKind))
+    invalid2("message_kind takes all, posts or comments");
+  if (target === "messages" && minMessages !== void 0)
+    invalid2("min_messages applies to stats contacts top");
+  if (minMessages !== void 0 && (!Number.isSafeInteger(minMessages) || minMessages < 1))
+    invalid2("min_messages takes a positive integer");
+  if (measure !== void 0 && !measures.includes(measure))
+    invalid2(`--measure takes ${measures.join(", ")}`);
+  if (measure !== void 0 && (score !== void 0 || given !== void 0))
+    invalid2("--measure cannot be combined with --score or --weights");
+  if (score !== void 0 && !["helpful", "active", "engaging"].includes(score))
+    invalid2("--score takes helpful, active or engaging");
+  if (target === "messages" && score !== void 0 && score !== "engaging")
+    invalid2("helpful and active scores apply to authors only");
+  const scoring = score !== void 0 || given !== void 0;
+  const preset = score;
+  let weights = null;
+  if (scoring) {
+    let raw = given !== void 0 ? given : target === "messages" ? { reactions: 0.5, "replies-from-others": 0.5 } : presets[preset];
+    if (typeof raw === "string") {
+      try {
+        raw = JSON.parse(raw);
+      } catch {
+        invalid2("--weights takes a JSON object of component weights");
+      }
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+      invalid2("--weights takes a JSON object of component weights");
+    const allowed = target === "messages" ? [...MESSAGE_MEASURES, "replies-from-others"] : [
+      ...AUTHOR_MEASURES.filter((name) => name !== "answer-time"),
+      "replies-from-others",
+      "reactions-per-message",
+      "replies-from-others-per-message"
+    ];
+    const entries = Object.entries(raw);
+    for (const [name, weight] of entries) {
+      if (!allowed.includes(name))
+        invalid2(`unknown ${target} score component: ${name}`);
+      if (typeof weight !== "number" || !Number.isFinite(weight) || weight < 0)
+        invalid2(`weight for ${name} must be a finite nonnegative number`);
+    }
+    if (!entries.some(([, weight]) => weight > 0))
+      invalid2("--weights needs at least one positive weight");
+    weights = Object.fromEntries(entries);
+  }
+  const selected = measure ?? (target === "messages" ? "reactions" : "messages");
+  return {
+    target,
+    messageKind,
+    minMessages: minMessages ?? (target === "contacts" && score === "engaging" ? 5 : 1),
+    measure: scoring ? "score" : selected,
+    order: !scoring && selected === "answer-time" ? "ascending" : "descending",
+    weights,
+    preset: scoring ? preset ?? "custom" : null,
+    components: weights === null ? [selected] : Object.entries(weights).filter(([, weight]) => weight > 0).map(([name]) => name)
+  };
+}, "rankingOptions");
+var rankingScore = /* @__PURE__ */ __name((raw, maxima, weights) => {
+  const entries = Object.entries(weights).filter(([, weight]) => weight > 0);
+  const scale = Math.max(...entries.map(([, weight]) => weight));
+  const denominator = entries.reduce((sum2, [, weight]) => sum2 + weight / scale, 0);
+  if (!Number.isFinite(scale) || scale <= 0 || !Number.isFinite(denominator) || denominator <= 0)
+    return null;
+  const normalized = {};
+  const contributions = {};
+  let sum = 0;
+  for (const [name, weight] of entries) {
+    const value = raw[name];
+    const maximum = maxima[name];
+    if (value == null || !Number.isFinite(value) || value < 0 || maximum === void 0 || !Number.isFinite(maximum) || maximum < value)
+      return null;
+    const part = maximum === 0 ? 0 : value / maximum;
+    normalized[name] = part;
+    contributions[name] = 100 * part * (weight / scale) / denominator;
+    sum += contributions[name];
+  }
+  return { score: Math.min(100, sum), normalized, contributions };
+}, "rankingScore");
+var RANKING_TOKENIZER_VERSION = 1;
+var withoutUrls = /* @__PURE__ */ __name((text) => text.replace(/\S+/gu, (token) => {
+  for (let offset = 0; ; ) {
+    const marker = token.indexOf("://", offset);
+    if (marker < 0)
+      break;
+    let start = marker;
+    while (start > 0 && /[a-z0-9+.-]/iu.test(token[start - 1]))
+      start--;
+    if (/^[a-z][a-z0-9+.-]*$/iu.test(token.slice(start, marker)) && (start === 0 || !/\w/u.test(token[start - 1])))
+      return token.slice(0, start);
+    offset = marker + 3;
+  }
+  const folded = token.toLowerCase();
+  for (let offset = 0; ; ) {
+    const start = folded.indexOf("www.", offset);
+    if (start < 0)
+      break;
+    if (start === 0 || !/\w/u.test(token[start - 1]))
+      return token.slice(0, start);
+    offset = start + 4;
+  }
+  return token;
+}), "withoutUrls");
+var rankingWords = /* @__PURE__ */ __name((text) => withoutUrls(text).match(/[\p{L}\p{N}]+/gu)?.length ?? 0, "rankingWords");
+var rankingQuestion = /* @__PURE__ */ __name((text) => withoutUrls(text).includes("?"), "rankingQuestion");
+
+export {
+  formatLocator,
+  isLocator,
+  parseLocator,
+  formatReference,
+  parseReference,
+  canonicalReference,
+  KINDS,
+  PROVIDERS,
+  FOLDER_PROVIDERS,
+  isFolderProvider,
+  folderProviderSql,
+  folderProviderOf,
+  DOCUMENT_ACCOUNT_PROVIDERS,
+  isDocumentAccountProvider,
+  filesAccountSql,
+  INTERNAL_NOTES,
+  UNKNOWN_PROVIDER,
+  providerEntryOf,
+  providers,
+  useProviders,
+  useStoredProviders,
+  addProvider,
+  isKind,
+  providerNamed,
+  kindIn,
+  kindOf,
+  COUNTER_FIELDS,
+  validCounter,
+  counterValue,
+  counterObservationTime,
+  observedCounters,
+  counterFreshness,
+  MESSAGE_MEASURES,
+  AUTHOR_MEASURES,
+  needsRankingContext,
+  rankingOptions,
+  rankingScore,
+  RANKING_TOKENIZER_VERSION,
+  rankingWords,
+  rankingQuestion
+};

package/dist/bundle/chunk-5BVIWP3S.js

@@ -0,0 +1,71 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/errors.js
+var errorCodes = [
+  "validation_error",
+  "configuration_error",
+  "authentication_error",
+  "permission_error",
+  "not_found",
+  "confirmation_required",
+  "rate_limited",
+  "timeout",
+  "network_error",
+  "provider_error",
+  "provider_unavailable",
+  "invalid_response",
+  "outcome_unknown",
+  "cancelled"
+];
+var BRAND = /* @__PURE__ */ Symbol.for("@wirecat/cli-base/CliError");
+var CliError = class extends Error {
+  static {
+    __name(this, "CliError");
+  }
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.details = details;
+    Object.defineProperty(this, BRAND, { value: true });
+  }
+};
+var isCliError = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && value[BRAND] === true, "isCliError");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/sanitize.js
+var CONTROL = (
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: matching them is the whole point
+  /[\u0000-\u0008\u000B-\u001F\u007F-\u009F\u200B\u200E\u200F\u202A-\u202E\u2066-\u2069\uFEFF\u{E0000}-\u{E007F}]/gu
+);
+var SUBDIVISION_FLAG = /\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}/gu;
+var LINE_BREAKS = /[\t\n\u2028\u2029]/g;
+var escaped = /* @__PURE__ */ __name((c) => {
+  const code = c.codePointAt(0) ?? 0;
+  if (code > 65535)
+    return `\\u{${code.toString(16)}}`;
+  return code > 255 ? `\\u${code.toString(16).padStart(4, "0")}` : `\\x${code.toString(16).padStart(2, "0")}`;
+}, "escaped");
+var visibleControls = /* @__PURE__ */ __name((text) => {
+  let at = 0;
+  let result = "";
+  for (const flag of text.matchAll(SUBDIVISION_FLAG)) {
+    result += text.slice(at, flag.index).replace(CONTROL, escaped) + flag[0];
+    at = flag.index + flag[0].length;
+  }
+  return result + text.slice(at).replace(CONTROL, escaped);
+}, "visibleControls");
+var singleLine = /* @__PURE__ */ __name((text) => visibleControls(text).replace(LINE_BREAKS, escaped), "singleLine");
+
+export {
+  errorCodes,
+  CliError,
+  isCliError,
+  visibleControls,
+  singleLine
+};