@wirecat/bitrix24-cli 0.0.0-stage → 0.2.0

package/dist/bundle/chunk-N6FLBXZS.js

@@ -0,0 +1,73 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  alive
+} from "./chunk-XJXONOB5.js";
+import {
+  resolvePaths,
+  writeSecurely
+} from "./chunk-IRV2PCQ2.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/background/lock.js
+import { existsSync, linkSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var lockPath = /* @__PURE__ */ __name((app, profile, env) => join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "serve", `${profile}.lock`), "lockPath");
+var readLock = /* @__PURE__ */ __name((path) => {
+  try {
+    const lock = JSON.parse(readFileSync(path, "utf8"));
+    return typeof lock.pid === "number" && typeof lock.startedAt === "string" ? lock : void 0;
+  } catch {
+    return void 0;
+  }
+}, "readLock");
+var holdLock = /* @__PURE__ */ __name((path, lock) => writeSecurely(path, `${JSON.stringify(lock)}
+`, 384), "holdLock");
+var takeLock = /* @__PURE__ */ __name((path, lock) => {
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  const draft = `${path}.${lock.pid}.tmp`;
+  writeFileSync(draft, `${JSON.stringify(lock)}
+`, { mode: 384 });
+  try {
+    for (let attempt = 0; attempt < 5; attempt++) {
+      try {
+        linkSync(draft, path);
+        return void 0;
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+      const held = readLock(path);
+      if (held && held.pid !== lock.pid && alive(held.pid))
+        return held;
+      rmSync(path, { force: true });
+    }
+    throw new Error(`could not take the lock ${path}: it keeps changing`);
+  } finally {
+    rmSync(draft, { force: true });
+  }
+}, "takeLock");
+var releaseLock = /* @__PURE__ */ __name((path, pid = process.pid) => {
+  if (readLock(path)?.pid === pid)
+    rmSync(path, { force: true });
+}, "releaseLock");
+var servingProfiles = /* @__PURE__ */ __name((app, env) => {
+  const dir = dirname(lockPath(app, "default", env));
+  if (!existsSync(dir))
+    return [];
+  return readdirSync(dir).filter((name) => name.endsWith(".lock")).map((name) => name.slice(0, -".lock".length)).filter((profile) => {
+    const lock = readLock(lockPath(app, profile, env));
+    return lock !== void 0 && alive(lock.pid);
+  });
+}, "servingProfiles");
+
+export {
+  lockPath,
+  readLock,
+  holdLock,
+  takeLock,
+  releaseLock,
+  servingProfiles
+};

package/dist/bundle/chunk-OTD2ZRXD.js

@@ -0,0 +1,161 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  holdLock,
+  readLock,
+  releaseLock,
+  takeLock
+} from "./chunk-N6FLBXZS.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/mcp/http/state.js
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/mcp/http/activity.js
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+var WRITE_EVERY_MS = 2e3;
+var TOOL_NAME = /^[A-Za-z0-9_.-]{1,64}$/;
+var httpActivityFile = /* @__PURE__ */ __name((tokenFile) => `${tokenFile.replace(/\.json$/, "")}.activity.json`, "httpActivityFile");
+var localDay = /* @__PURE__ */ __name((ms) => {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}, "localDay");
+var readActivity = /* @__PURE__ */ __name((path) => {
+  if (!existsSync(path))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}, "readActivity");
+var calledTools = /* @__PURE__ */ __name((body) => (Array.isArray(body) ? body : [body]).flatMap((message) => {
+  if (!message || typeof message !== "object")
+    return [];
+  const { method, params } = message;
+  const name = params?.name;
+  return method === "tools/call" && typeof name === "string" && TOOL_NAME.test(name) ? [name] : [];
+}), "calledTools");
+var activityRecorder = /* @__PURE__ */ __name((path, now = Date.now) => {
+  const activity = readActivity(path);
+  let timer;
+  const write = /* @__PURE__ */ __name(() => {
+    timer = void 0;
+    try {
+      mkdirSync(dirname(path), { recursive: true, mode: 448 });
+      const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+      writeFileSync(temporary, JSON.stringify(activity), { mode: 384, flag: "wx" });
+      chmodSync(temporary, 384);
+      renameSync(temporary, path);
+    } catch {
+    }
+  }, "write");
+  return {
+    record: /* @__PURE__ */ __name((clientId, tools) => {
+      const at = now();
+      const iso = new Date(at).toISOString();
+      const day = localDay(at);
+      const before = activity[clientId];
+      const counted = before?.day === day ? before.toolCalls : 0;
+      const last = tools.at(-1);
+      activity[clientId] = {
+        lastRequestAt: iso,
+        day,
+        toolCalls: counted + tools.length,
+        ...last ? { lastTool: last, lastToolAt: iso } : before?.lastTool ? { lastTool: before.lastTool, ...before.lastToolAt ? { lastToolAt: before.lastToolAt } : {} } : {}
+      };
+      if (last) {
+        clearTimeout(timer);
+        write();
+      } else if (!timer) {
+        timer = setTimeout(write, WRITE_EVERY_MS);
+        timer.unref();
+      }
+    }, "record"),
+    flush: /* @__PURE__ */ __name(() => {
+      if (!timer)
+        return;
+      clearTimeout(timer);
+      write();
+    }, "flush")
+  };
+}, "activityRecorder");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/mcp/http/state.js
+var ACCESS_SECONDS = 60 * 60;
+var REFRESH_SECONDS = 30 * 24 * 60 * 60;
+var readStored = /* @__PURE__ */ __name((path) => existsSync2(path) ? JSON.parse(readFileSync2(path, "utf8")) : { clients: [], tokens: [] }, "readStored");
+var mcpHttpMarker = /* @__PURE__ */ __name((envPrefix) => `${envPrefix}_MCP_HTTP`, "mcpHttpMarker");
+var httpLogFile = /* @__PURE__ */ __name((tokenFile) => `${tokenFile.replace(/\.json$/, "")}.log`, "httpLogFile");
+var httpLockFile = /* @__PURE__ */ __name((tokenFile) => `${tokenFile.replace(/\.json$/, "")}.lock`, "httpLockFile");
+var httpLaunchFile = /* @__PURE__ */ __name((lockFile) => `${lockFile.replace(/\.lock$/, "")}.launch.json`, "httpLaunchFile");
+var readHttpLaunch = /* @__PURE__ */ __name((path) => {
+  try {
+    const launch = JSON.parse(readFileSync2(path, "utf8"));
+    return typeof launch.invocation === "string" && Array.isArray(launch.argv) && launch.argv.every((word) => typeof word === "string") && typeof launch.env === "object" && launch.env !== null ? launch : void 0;
+  } catch {
+    return void 0;
+  }
+}, "readHttpLaunch");
+var readHttpLock = /* @__PURE__ */ __name((path) => {
+  const lock = readLock(path);
+  return lock && typeof lock.port === "number" && typeof lock.publicUrl === "string" ? lock : void 0;
+}, "readHttpLock");
+var httpLock = /* @__PURE__ */ __name((path, first) => {
+  let current = first;
+  const held = takeLock(path, current);
+  return {
+    held,
+    update: /* @__PURE__ */ __name((change) => {
+      current = { ...current, ...change };
+      holdLock(path, current);
+    }, "update"),
+    release: /* @__PURE__ */ __name(() => releaseLock(path), "release")
+  };
+}, "httpLock");
+var signedInClients = /* @__PURE__ */ __name((tokenFile, now = Date.now()) => {
+  const seconds = Math.floor(now / 1e3);
+  const { clients, tokens } = readStored(tokenFile);
+  const activity = readActivity(httpActivityFile(tokenFile));
+  const today = localDay(now);
+  const last = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    if (token.expiresAt <= seconds)
+      continue;
+    const issued = token.expiresAt - (token.kind === "access" ? ACCESS_SECONDS : REFRESH_SECONDS);
+    last.set(token.clientId, Math.max(last.get(token.clientId) ?? 0, issued));
+  }
+  return clients.filter((client) => last.has(client.id)).map((client) => {
+    const did = activity[client.id];
+    return {
+      claimedName: client.name ?? null,
+      lastLoginAt: new Date((last.get(client.id) ?? 0) * 1e3).toISOString(),
+      lastRequestAt: did?.lastRequestAt ?? null,
+      lastTool: did?.lastTool ?? null,
+      lastToolAt: did?.lastToolAt ?? null,
+      toolCallsToday: did?.day === today ? did.toolCalls : 0
+    };
+  }).sort((a, b) => b.lastLoginAt.localeCompare(a.lastLoginAt));
+}, "signedInClients");
+
+export {
+  httpActivityFile,
+  calledTools,
+  activityRecorder,
+  ACCESS_SECONDS,
+  REFRESH_SECONDS,
+  readStored,
+  mcpHttpMarker,
+  httpLogFile,
+  httpLockFile,
+  httpLaunchFile,
+  readHttpLaunch,
+  readHttpLock,
+  httpLock,
+  signedInClients
+};

package/dist/bundle/chunk-P33NDCDI.js

@@ -0,0 +1,78 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/http/listen.js
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+var MAX_BODY = 4 * 1024 * 1024;
+var TooLarge = class extends Error {
+  static {
+    __name(this, "TooLarge");
+  }
+};
+var readBody = /* @__PURE__ */ __name((incoming, limit) => new Promise((resolve, reject) => {
+  if (Number(incoming.headers["content-length"] ?? 0) > limit)
+    return reject(new TooLarge());
+  const chunks = [];
+  let size = 0;
+  incoming.on("data", (chunk) => {
+    size += chunk.length;
+    if (size > limit) {
+      incoming.destroy();
+      reject(new TooLarge());
+    } else
+      chunks.push(chunk);
+  });
+  incoming.once("end", () => resolve(Buffer.concat(chunks)));
+  incoming.once("error", reject);
+}), "readBody");
+var toRequest = /* @__PURE__ */ __name(async (incoming, origin, maxBody) => {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(incoming.headers)) {
+    if (Array.isArray(value))
+      for (const one of value)
+        headers.append(name, one);
+    else if (value !== void 0)
+      headers.set(name, value);
+  }
+  const method = incoming.method ?? "GET";
+  const body = method === "GET" || method === "HEAD" ? void 0 : await readBody(incoming, maxBody);
+  if (body)
+    headers.set("content-length", String(body.length));
+  return new Request(new URL(incoming.url ?? "/", origin), { method, headers, ...body ? { body } : {} });
+}, "toRequest");
+var send = /* @__PURE__ */ __name(async (response, outgoing) => {
+  outgoing.writeHead(response.status, Object.fromEntries(response.headers));
+  if (!response.body)
+    return void outgoing.end();
+  const body = Readable.fromWeb(response.body);
+  outgoing.once("close", () => body.destroy());
+  body.pipe(outgoing);
+}, "send");
+var listen = /* @__PURE__ */ __name((handle, { host, port, maxBody = MAX_BODY }) => new Promise((resolve, reject) => {
+  const server = createServer((incoming, outgoing) => {
+    toRequest(incoming, `http://${host}`, maxBody).then(handle).then((response) => send(response, outgoing)).catch((error) => {
+      if (!outgoing.headersSent)
+        outgoing.writeHead(error instanceof TooLarge ? 413 : 500, { connection: "close" });
+      outgoing.end();
+    });
+  });
+  server.once("error", reject);
+  server.listen(port, host, () => {
+    const { port: bound } = server.address();
+    resolve({
+      url: new URL(`http://${host}:${bound}`),
+      close: /* @__PURE__ */ __name(() => new Promise((done) => {
+        server.close(() => done());
+        server.closeAllConnections();
+      }), "close")
+    });
+  });
+}), "listen");
+
+export {
+  listen
+};

package/dist/bundle/chunk-P364PLIK.js

@@ -0,0 +1,257 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError,
+  array,
+  boolean,
+  integer,
+  isoTime,
+  isoTimestamp,
+  minLength,
+  minValue,
+  nullable,
+  number,
+  optional,
+  picklist,
+  pipe,
+  record,
+  reference,
+  strictObject,
+  string,
+  unknown
+} from "./chunk-IRV2PCQ2.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/tasks/model.js
+var TASK_KINDS = ["question", "request", "mention", "promise"];
+var TASK_STATES = ["open", "todo", "in_progress", "done", "dismissed"];
+var CLOSED_STATES = ["done", "dismissed"];
+var TASK_ORIGINS = ["rule", "agent", "owner"];
+var TASK_VERDICTS = ["useful", "not_useful"];
+var isClosedState = /* @__PURE__ */ __name((state) => CLOSED_STATES.includes(state), "isClosedState");
+function closeTask(task, state, by, at, reason) {
+  if (isClosedState(task.state))
+    throw new CliError("validation_error", `task ${task.id} is already ${task.state}`, { reason: "task.closed" });
+  const { claimedBy: _by, claimedUntil: _until, ...unclaimed } = task;
+  return { ...unclaimed, state, closedAt: at, closedBy: by, ...reason === void 0 ? {} : { reason } };
+}
+__name(closeTask, "closeTask");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/tasks/store.js
+function matches(task, filter) {
+  return (filter.account === void 0 || task.account === filter.account) && (filter.state === void 0 || task.state === filter.state) && (filter.group === void 0 || task.group === filter.group) && (filter.kind === void 0 || task.kind === filter.kind) && (filter.createdBefore === void 0 || task.createdAt < filter.createdBefore);
+}
+__name(matches, "matches");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/tasks/priority.js
+var PRIORITY_LABELS = ["low", "medium", "high", "critical"];
+var MIDDLE = { low: 0.125, medium: 0.375, high: 0.625, critical: 0.875 };
+var LEGACY_PRIORITY_SCORES = [0.875, 0.625, 0.375, 0.1875, 0.0625];
+var priorityLabel = /* @__PURE__ */ __name((score) => score === null ? null : PRIORITY_LABELS[Math.min(3, Math.max(0, Math.floor(score * 4)))], "priorityLabel");
+var priorityBand = /* @__PURE__ */ __name((label) => {
+  const at = PRIORITY_LABELS.indexOf(label);
+  return { from: at / 4, to: (at + 1) / 4 };
+}, "priorityBand");
+var legacyPriority = /* @__PURE__ */ __name((score) => score === null ? null : score < 0.125 ? 4 : 3 - PRIORITY_LABELS.indexOf(priorityLabel(score)), "legacyPriority");
+var checkedScore = /* @__PURE__ */ __name((score) => {
+  if (!Number.isFinite(score) || score < 0 || score > 1)
+    throw new CliError("validation_error", "a priority score is 0 to 1");
+  return score;
+}, "checkedScore");
+var priorityOf = /* @__PURE__ */ __name((value) => {
+  const word = value.trim().toLowerCase();
+  if (word === "none")
+    return null;
+  if (PRIORITY_LABELS.includes(word))
+    return MIDDLE[word];
+  if (/^[0-4]$/.test(word))
+    return LEGACY_PRIORITY_SCORES[Number(word)];
+  if (/^(0?\.\d+|[01]\.\d*)$/.test(word) && Number(word) <= 1)
+    return Number(word);
+  throw new CliError("validation_error", `a priority is ${PRIORITY_LABELS.join(", ")}, none, or a score from 0.0 to 1.0 with its decimal point; 0 (urgent) \u2026 4 (low) still work as critical, high, medium, low, low`);
+}, "priorityOf");
+var priorityOption = /* @__PURE__ */ __name((value) => priorityOf(value) ?? "none", "priorityOption");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/tasks/service.js
+function createTaskService({ store, now = /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "now"), newId = /* @__PURE__ */ __name(() => crypto.randomUUID(), "newId") }) {
+  async function find(id2) {
+    const task = await store.get(id2);
+    if (!task)
+      throw new CliError("not_found", `no task ${id2}`);
+    return task;
+  }
+  __name(find, "find");
+  return {
+    /**
+     * A rule never makes a second task from a source it has seen, whatever that task's state, so a
+     * dismissed one stays dismissed — nor from a message attached or merged into a task. A person or an agent may
+     * add a task of another kind to it. A task a rule opens goes through the host's duplicate check.
+     */
+    async add(input) {
+      const rule = input.origin === "rule";
+      const existing = await store.findBySource(input.account, input.source, rule ? { linked: true } : void 0);
+      const same = rule ? existing[0] : existing.find((task2) => task2.kind === input.kind);
+      if (same)
+        return { task: same, created: false };
+      const task = { ...input, id: newId(), state: "open", createdAt: now() };
+      await store.insert(task);
+      if (!rule || !store.reviewDuplicates)
+        return { task, created: true };
+      return { task, created: true, review: await store.reviewDuplicates(task.id) };
+    },
+    async close(id2, { as, by, reason }) {
+      const task = closeTask(await find(id2), as, by, now(), reason);
+      await store.update(task);
+      return task;
+    },
+    list: /* @__PURE__ */ __name((filter = {}) => store.list(filter), "list"),
+    async stats(filter = {}) {
+      const byGroup = /* @__PURE__ */ new Map();
+      for (const task of await store.list(filter))
+        byGroup.set(task.group, [...byGroup.get(task.group) ?? [], task]);
+      return [...byGroup].map(([group, tasks]) => {
+        const open = tasks.filter((task) => !isClosedState(task.state));
+        const closeMs = tasks.flatMap((task) => task.closedAt ? [task.closedAt.getTime() - task.createdAt.getTime()] : []);
+        const oldestOpenAt = open.map((task) => task.createdAt).sort((a, b) => a.getTime() - b.getTime())[0];
+        return {
+          group,
+          open: open.length,
+          ...oldestOpenAt ? { oldestOpenAt } : {},
+          ...closeMs.length > 0 ? { medianCloseMs: median(closeMs) } : {}
+        };
+      });
+    }
+  };
+}
+__name(createTaskService, "createTaskService");
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  const upper = sorted[middle] ?? 0;
+  return sorted.length % 2 === 1 ? upper : ((sorted[middle - 1] ?? 0) + upper) / 2;
+}
+__name(median, "median");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/domain/knowledge.js
+var FACT_STATUSES = ["proposed", "accepted", "superseded", "reversed", "rejected"];
+var MEMORY_KINDS = ["summary", "digest", "preference"];
+var MEMORY_STATUSES = ["proposed", "confirmed", "stale", "superseded"];
+var MEMORY_SCOPES = ["personal", "work"];
+var WORK_TASK_TYPES = ["bug", "feature", "chore"];
+var TASK_TYPES = [...WORK_TASK_TYPES, ...TASK_KINDS];
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/store/sqlite/link-kinds.js
+var LINK_KINDS = [
+  "links-to",
+  "blocked-by",
+  "follow-up-of",
+  "about",
+  "member-of",
+  "labelled",
+  "answered-by",
+  "evidence",
+  "created-from",
+  "duplicate-of",
+  "related-to",
+  "assigned-to",
+  "attached"
+];
+var LINK_ORIGINS = ["file", "owner", "suggested", "message"];
+var LINK_SOURCES = [...LINK_ORIGINS, "calendar"];
+var RELATION_KINDS = ["member-of", "related-to"];
+var linkKind = /* @__PURE__ */ __name((kind) => `'${kind}'`, "linkKind");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/entities/fields.js
+var text = string();
+var id = pipe(string(), minLength(1));
+var time = isoTime;
+var zonedTime = pipe(string(), isoTimestamp("an ISO 8601 time with a zone"));
+var count = pipe(number(), integer(), minValue(0));
+var untrusted = optional(array(text));
+var providerMetadata = optional(record(string(), unknown()));
+var evidenceSource = strictObject({
+  ref: nullable(reference),
+  kind: text,
+  title: nullable(text),
+  sender: nullable(text),
+  at: nullable(time),
+  excerpt: nullable(text),
+  tool: nullable(text),
+  missing: boolean()
+});
+var author = strictObject({
+  type: picklist(["person", "bot"]),
+  id,
+  name: nullable(text)
+});
+
+// node_modules/.pnpm/@wirecat+cli-core@0.586.0_@wirecat+cli-base@0.79.0_commander@15.0.0_esbuild@0.28.2_type_bdecddef0ae5a50ae90cab8b9e35c13b/node_modules/@wirecat/cli-core/dist/entities/knowledge-lists.js
+var organization = strictObject({
+  id,
+  ref: reference,
+  kind: picklist(["company", "team", "family", "community"]),
+  name: text,
+  scope: picklist(["personal", "work"]),
+  created_at: time
+});
+var project = strictObject({
+  id,
+  ref: reference,
+  key: text,
+  name: text,
+  kind: picklist(["project", "inbox"]),
+  type: picklist(["work", "client", "personal", "oss", "other"]),
+  organization_id: nullable(id),
+  scope: picklist(["personal", "work"]),
+  created_at: time
+});
+var reminder = strictObject({
+  id,
+  task: text,
+  due_at: time,
+  timezone: text,
+  state: picklist(["pending", "leased", "delivered", "cancelled"]),
+  revision: number(),
+  receipt: nullable(text)
+});
+
+export {
+  text,
+  id,
+  time,
+  zonedTime,
+  count,
+  untrusted,
+  providerMetadata,
+  evidenceSource,
+  author,
+  TASK_KINDS,
+  TASK_STATES,
+  TASK_ORIGINS,
+  TASK_VERDICTS,
+  isClosedState,
+  PRIORITY_LABELS,
+  priorityLabel,
+  priorityBand,
+  legacyPriority,
+  checkedScore,
+  priorityOption,
+  createTaskService,
+  matches,
+  FACT_STATUSES,
+  MEMORY_KINDS,
+  MEMORY_STATUSES,
+  MEMORY_SCOPES,
+  WORK_TASK_TYPES,
+  TASK_TYPES,
+  organization,
+  project,
+  reminder,
+  LINK_KINDS,
+  LINK_ORIGINS,
+  LINK_SOURCES,
+  RELATION_KINDS,
+  linkKind
+};