@wirecat/bitrix24-cli 0.0.0-stage → 0.2.0

package/dist/bundle/bun-H6RSODZ3.js

@@ -0,0 +1,169 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  DefaultLogger,
+  DrizzleQueryError,
+  NoopLogger,
+  SQLiteAsyncDatabase,
+  SQLiteAsyncPreparedQuery,
+  SQLiteAsyncSession,
+  SQLiteAsyncTransaction,
+  SQLiteDialect,
+  booleanFromInteger,
+  bufferFromBytes,
+  castToText,
+  dateFromStoredMilliseconds,
+  dateFromStoredSeconds,
+  entityKind,
+  jitCompatCheck,
+  refineSqliteCodecs,
+  sql
+} from "./chunk-SFRNX2TI.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/store/sqlite/drizzle/bun.js
+import { Database } from "bun:sqlite";
+var bunSQLiteCodecs = refineSqliteCodecs({
+  "integer:boolean": { normalize: booleanFromInteger },
+  "integer:timestamp": { normalize: dateFromStoredSeconds },
+  "integer:timestamp_ms": { normalize: dateFromStoredMilliseconds },
+  "text:json": { normalize: JSON.parse },
+  blob: { normalize: bufferFromBytes },
+  "blob:json": {
+    cast: castToText,
+    normalize: JSON.parse
+  },
+  "blob:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  },
+  numeric: {
+    cast: castToText,
+    normalize: String
+  },
+  "numeric:number": { normalize: Number },
+  "numeric:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  }
+});
+var SQLiteBunSession = class extends SQLiteAsyncSession {
+  static {
+    __name(this, "SQLiteBunSession");
+  }
+  client;
+  relations;
+  options;
+  static [entityKind] = "SQLiteBunSession";
+  logger;
+  constructor(client, dialect, relations, options = {}) {
+    super(dialect, "sync");
+    this.client = client;
+    this.relations = relations;
+    this.options = options;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  exec(query) {
+    this.client.exec(query);
+  }
+  prepareQuery(query, mode, _prepare, executeMethod, mapper, queryMetadata) {
+    let stmt;
+    try {
+      stmt = this.client.query(query.sql);
+    } catch (e) {
+      throw new DrizzleQueryError(query.sql, this.options.paramsInErrors ? query.params : void 0, e);
+    }
+    return new SQLiteAsyncPreparedQuery("sync", executeMethod, {
+      all: /* @__PURE__ */ __name((params) => {
+        if (mode === "arrays") return stmt.values(...params);
+        return stmt.all(...params);
+      }, "all"),
+      get: /* @__PURE__ */ __name((params) => {
+        if (mode === "arrays") return stmt.values(...params)[0];
+        return stmt.get(...params);
+      }, "get"),
+      run: /* @__PURE__ */ __name((params) => {
+        return stmt.run(...params);
+      }, "run")
+    }, query, mapper, mode, this.logger, void 0, queryMetadata, void 0, this.options.paramsInErrors);
+  }
+  transaction(transaction, config = {}) {
+    const tx = new SQLiteBunTransaction("sync", this.dialect, this, this.relations);
+    let result;
+    const nativeTx = this.client.transaction(() => {
+      result = transaction(tx);
+    });
+    if (config.behavior === "concurrent") throw new Error("Concurrent transactions are not supported by driver");
+    nativeTx[config.behavior ?? "deferred"]();
+    return result;
+  }
+};
+var SQLiteBunTransaction = class SQLiteBunTransaction2 extends SQLiteAsyncTransaction {
+  static {
+    __name(this, "SQLiteBunTransaction2");
+  }
+  static [entityKind] = "SQLiteBunTransaction";
+  transaction(transaction) {
+    const savepointName = `sp${this.nestedIndex}`;
+    const tx = new SQLiteBunTransaction2("sync", this.dialect, this.session, this._.relations, this.nestedIndex + 1);
+    this.session.run(sql.raw(`savepoint ${savepointName}`));
+    try {
+      const result = transaction(tx);
+      this.session.run(sql.raw(`release savepoint ${savepointName}`));
+      return result;
+    } catch (err) {
+      try {
+        this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
+      } catch {
+      }
+      throw err;
+    }
+  }
+};
+var SQLiteBunDatabase = class extends SQLiteAsyncDatabase {
+  static {
+    __name(this, "SQLiteBunDatabase");
+  }
+  static [entityKind] = "SQLiteBunDatabase";
+};
+function construct(client, config = {}) {
+  const dialect = new SQLiteDialect({
+    codecs: config.codecs ?? bunSQLiteCodecs,
+    useJitMappers: jitCompatCheck(config.jit)
+  });
+  let logger;
+  if (config.logger === true) logger = new DefaultLogger();
+  else if (config.logger !== false) logger = config.logger;
+  const relations = config.relations ?? {};
+  const db = new SQLiteBunDatabase("sync", dialect, new SQLiteBunSession(client, dialect, relations, {
+    logger,
+    paramsInErrors: config.paramsInErrors
+  }), relations);
+  db.$client = client;
+  return db;
+}
+__name(construct, "construct");
+function drizzle(...params) {
+  if (params[0] === void 0 || typeof params[0] === "string") return construct(params[0] === void 0 ? new Database() : new Database(params[0]), params[1]);
+  const { connection, client, ...DrizzleSQLiteConfig } = params[0];
+  if (client) return construct(client, DrizzleSQLiteConfig);
+  if (typeof connection === "object") {
+    const { source, ...opts } = connection;
+    const options = Object.values(opts).filter((v) => v !== void 0).length ? opts : void 0;
+    return construct(new Database(source, options), DrizzleSQLiteConfig);
+  }
+  return construct(new Database(connection), DrizzleSQLiteConfig);
+}
+__name(drizzle, "drizzle");
+(function(_drizzle) {
+  function mock(config) {
+    return construct({}, config);
+  }
+  __name(mock, "mock");
+  _drizzle.mock = mock;
+})(drizzle || (drizzle = {}));
+export {
+  drizzle
+};

package/dist/bundle/bun-sqlite-BO4LTQHX.js

@@ -0,0 +1,69 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  loadVectorExtension,
+  vectorExtension
+} from "./chunk-WII44RXN.js";
+import "./chunk-IRV2PCQ2.js";
+import {
+  importFrom
+} from "./chunk-Y5E2WNWB.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/store/drivers/bun-sqlite.js
+var customised = false;
+var ownLibrary = /* @__PURE__ */ __name(async () => {
+  try {
+    const { libraryFor } = await importFrom(new URL("store/drivers/bun-sqlite.js", import.meta.resolve("@wirecat/cli-core")).href, "@wirecat/cli-core-sqlite");
+    return libraryFor();
+  } catch {
+    return void 0;
+  }
+}, "ownLibrary");
+var bunDatabase = /* @__PURE__ */ __name(async () => {
+  const specifier = "bun:sqlite";
+  const { Database } = await importFrom(new URL("store/drivers/bun-sqlite.js", import.meta.resolve("@wirecat/cli-core")).href, specifier);
+  if (process.platform === "darwin" && !customised) {
+    customised = true;
+    const library = await ownLibrary();
+    if (library)
+      Database.setCustomSQLite(library);
+  }
+  return Database;
+}, "bunDatabase");
+var openWithBunSqlite = /* @__PURE__ */ __name(async (path) => cacheOverBunSqlite(await bunClient(path)), "openWithBunSqlite");
+var bunClient = /* @__PURE__ */ __name(async (path, options) => {
+  const Database = await bunDatabase();
+  const extension = await vectorExtension();
+  const client = options ? new Database(path, options) : new Database(path);
+  try {
+    loadVectorExtension(client, extension);
+    return client;
+  } catch (error) {
+    client.close();
+    throw error;
+  }
+}, "bunClient");
+var cacheOverBunSqlite = /* @__PURE__ */ __name((database) => {
+  return {
+    exec: /* @__PURE__ */ __name((sql) => database.exec(sql), "exec"),
+    prepare: /* @__PURE__ */ __name((sql) => {
+      const statement = database.query(sql);
+      return {
+        run: /* @__PURE__ */ __name((...parameters) => ({ changes: Number(statement.run(...parameters).changes) }), "run"),
+        // Bun answers null for no row; the seam promises undefined, and `!== undefined` checks rely on it.
+        get: /* @__PURE__ */ __name((...parameters) => statement.get(...parameters) ?? void 0, "get"),
+        all: /* @__PURE__ */ __name((...parameters) => statement.all(...parameters), "all")
+      };
+    }, "prepare"),
+    close: /* @__PURE__ */ __name(() => database.close(), "close")
+  };
+}, "cacheOverBunSqlite");
+export {
+  bunClient,
+  bunDatabase,
+  cacheOverBunSqlite,
+  openWithBunSqlite
+};

package/dist/bundle/chunk-2KCZ7BKW.js

@@ -0,0 +1,215 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  installerOf,
+  updateCommand
+} from "./chunk-EVYSBZ3I.js";
+import {
+  QUESTIONS,
+  readSetupAnswers,
+  unanswered,
+  writeSetupAnswers
+} from "./chunk-CNNEA2M4.js";
+import {
+  DEFAULT_STEMMERS,
+  LANGUAGES
+} from "./chunk-VEWWAGTD.js";
+import {
+  sharedConfigPath
+} from "./chunk-TE3FR6MI.js";
+import {
+  storePath
+} from "./chunk-DTXERR44.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/cli/first-run.js
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, realpathSync } from "node:fs";
+import { delimiter, join } from "node:path";
+var SKIPPED = /* @__PURE__ */ new Set(["help", "guide", "completion", "mcp", "serve", "server", "update", "store"]);
+var asksAtStart = /* @__PURE__ */ __name((start) => !start.headless && start.terminal && !start.env.AI_AGENT && !start.env.CLAUDECODE && start.readOnlyLock === void 0 && !SKIPPED.has(start.path[0] ?? ""), "asksAtStart");
+var systemLanguage = /* @__PURE__ */ __name((env) => {
+  const named = [env.LC_ALL, env.LC_MESSAGES, env.LANG, ...(env.LANGUAGE ?? "").split(":")].map((value) => value?.trim()).find((value) => value && value !== "C" && value !== "POSIX" && !value.startsWith("C."));
+  return (named ?? Intl.DateTimeFormat().resolvedOptions().locale).slice(0, 2).toLowerCase();
+}, "systemLanguage");
+var stemmersOf = /* @__PURE__ */ __name((languages) => {
+  const latin = LANGUAGES.filter(({ name, script }) => script === "latin" && languages.includes(name));
+  return {
+    cyrillic: languages.includes("russian") ? "russian" : "none",
+    latin: latin.length ? latin.map(({ name }) => name).join(",") : "none"
+  };
+}, "stemmersOf");
+var languagesOf = /* @__PURE__ */ __name((stemmers) => LANGUAGES.filter(({ name }) => stemmers.cyrillic === name || stemmers.latin.split(",").includes(name)).map(({ name }) => name), "languagesOf");
+var choose = /* @__PURE__ */ __name(async (io, prompt, count, chosen) => {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const answer = (await io.ask(prompt)).trim();
+    if (!answer)
+      return chosen;
+    if (/^(none|-)$/i.test(answer))
+      return [];
+    const numbers = answer.split(/[\s,]+/).filter(Boolean).map(Number);
+    if (numbers.every((number) => Number.isInteger(number) && number >= 1 && number <= count))
+      return [...new Set(numbers)].sort((a, b) => a - b);
+    io.say(`Choose numbers from 1 to ${count}, separated by commas.`);
+  }
+  return chosen;
+}, "choose");
+var yes = /* @__PURE__ */ __name(async (io, prompt) => /^y(es)?$/i.test((await io.ask(prompt)).trim()), "yes");
+var onPath = /* @__PURE__ */ __name((command, env) => {
+  const names = process.platform === "win32" ? [".cmd", ".exe", ""].map((ending) => command + ending) : [command];
+  return (env.PATH ?? env.Path ?? "").split(delimiter).some((folder) => names.some((name) => {
+    try {
+      accessSync(join(folder, name), process.platform === "win32" ? constants.F_OK : constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }));
+}, "onPath");
+var installWith = /* @__PURE__ */ __name((argv) => spawnSync(argv[0], argv.slice(1), { stdio: ["inherit", 2, 2] }).status === 0, "installWith");
+var installerHere = /* @__PURE__ */ __name(() => {
+  try {
+    return installerOf(realpathSync(process.argv[1] ?? ""));
+  } catch {
+    return "unknown";
+  }
+}, "installerHere");
+var suggested = /* @__PURE__ */ __name((env, contentLanguages) => {
+  const own = LANGUAGES.filter(({ code }) => contentLanguages?.includes(code));
+  const system = systemLanguage(env);
+  return (own.length ? own : LANGUAGES.filter(({ code }) => code === "en" || code === system)).map(({ name }) => name);
+}, "suggested");
+var askLanguages = /* @__PURE__ */ __name(async ({ command, env, io, contentLanguages }) => {
+  const { openStore } = await import("./store-7O4JQD2Z.js");
+  const store = await openStore({ env });
+  let rebuild = false;
+  try {
+    const saved = await store.searchIndex.stemmers() ?? void 0;
+    const inUse = saved !== void 0 || (await store.accounts.accounts()).length > 0;
+    const ticked = inUse ? languagesOf(saved ?? DEFAULT_STEMMERS) : suggested(env, contentLanguages);
+    const numbers = ticked.map((name) => LANGUAGES.findIndex((one) => one.name === name) + 1);
+    io.say("Languages you write and speak \u2014 search finds every form of their words, and spellings speech mangles:");
+    LANGUAGES.forEach(({ name, label }, at) => {
+      io.say(`  ${at + 1}. ${label}${ticked.includes(name) ? " \u2713" : ""}`);
+    });
+    const chosen = await choose(io, `Numbers (${numbers.join(",")}): `, LANGUAGES.length, numbers);
+    const next = stemmersOf(chosen.map((number) => LANGUAGES[number - 1].name));
+    const before = saved ?? DEFAULT_STEMMERS;
+    if (inUse && before.cyrillic === next.cyrillic && before.latin === next.latin)
+      return;
+    if (inUse && !await yes(io, "Rebuild the word forms of every stored message now? Word search waits for it; a large store takes minutes. [y/N] ")) {
+      io.say(`Languages kept as they were; \`${command} setup\` asks again.`);
+      return;
+    }
+    await store.searchIndex.saveStemmers(next);
+    rebuild = inUse;
+  } finally {
+    await store.close();
+  }
+  if (!rebuild)
+    return;
+  const [{ openCache }, { buildStems }] = await Promise.all([
+    import("./open-E47QYKFC.js"),
+    import("./store-maintenance-command-UDVGEY2D.js")
+  ]);
+  const database = await openCache(storePath(env));
+  try {
+    buildStems(database, (note) => io.say(`  ${note}`), { force: true });
+  } finally {
+    database.close();
+  }
+}, "askLanguages");
+var askTools = /* @__PURE__ */ __name(async (run) => {
+  const { command, env, io } = run;
+  const installed = run.installed ?? ((name) => onPath(name, env));
+  const { WIRECAT_TOOLS } = await import("./first-screen-VQM4MTS7.js");
+  const others = WIRECAT_TOOLS.filter((tool) => tool.command !== command);
+  const missing = others.filter((tool) => !installed(tool.command));
+  io.say("Other WireCat tools \u2014 they share this store, so one search finds everything:");
+  for (const tool of others) {
+    const at = missing.indexOf(tool);
+    io.say(`  ${at < 0 ? "\u2713 " : `${at + 1}.`} ${tool.command} \u2014 ${tool.does}`);
+  }
+  if (!missing.length)
+    return;
+  const chosen = await choose(io, "Numbers to install (none): ", missing.length, []);
+  const installer = run.installer ?? installerHere();
+  for (const number of chosen) {
+    const tool = missing[number - 1];
+    const argv = updateCommand(installer, tool.package);
+    if (!argv) {
+      io.say(`Install ${tool.command} with \`npm install -g ${tool.package}\`.`);
+      continue;
+    }
+    io.say(`Installing ${tool.command}: ${argv.join(" ")}`);
+    if (!(run.install ?? installWith)(argv))
+      io.say(`${tool.command} was not installed; run \`${argv.join(" ")}\`.`);
+  }
+}, "askTools");
+var PERMISSION_CHOICES = [
+  { answer: "readonly", text: "read only \u2014 search and read; nothing sends or changes" },
+  { answer: "allow", text: "read and write \u2014 as each profile's permissions allow" }
+];
+var askPermissions = /* @__PURE__ */ __name(async ({ io }, answers) => {
+  const now = answers.permissions ?? "allow";
+  const current = Math.max(1, PERMISSION_CHOICES.findIndex(({ answer }) => answer === now) + 1);
+  io.say("Read only, or read and write? The same for you, scripts and agents over MCP, in every WireCat tool:");
+  PERMISSION_CHOICES.forEach(({ text }, at) => {
+    io.say(`  ${at + 1}. ${text}`);
+  });
+  const [chosen = current] = await choose(io, `Number (${current}): `, PERMISSION_CHOICES.length, [current]);
+  return PERMISSION_CHOICES[chosen - 1].answer;
+}, "askPermissions");
+var answersAt = /* @__PURE__ */ __name((path) => {
+  try {
+    return readSetupAnswers(path);
+  } catch {
+    return {};
+  }
+}, "answersAt");
+var askSetupQuestions = /* @__PURE__ */ __name(async (run) => {
+  const path = sharedConfigPath(storePath(run.env), run.env);
+  const answers = answersAt(path);
+  const asking = run.all ? [...QUESTIONS] : unanswered(answers);
+  for (const question of asking) {
+    run.io.say("");
+    if (question === "languages") {
+      await askLanguages(run);
+      writeSetupAnswers(path, { languages: true });
+    } else if (question === "tools") {
+      await askTools(run);
+      writeSetupAnswers(path, { tools: true });
+    } else
+      writeSetupAnswers(path, { permissions: await askPermissions(run, answers) });
+  }
+  return asking;
+}, "askSetupQuestions");
+var setupAtStart = /* @__PURE__ */ __name(async (start) => {
+  const input = start.input ?? process.stdin;
+  const terminal = start.terminal ?? (input.isTTY === true && process.stderr.isTTY === true);
+  if (!asksAtStart({ ...start, terminal, readOnlyLock: start.readOnlyLock }))
+    return;
+  await askSetupQuestions({
+    command: start.command,
+    env: start.env,
+    contentLanguages: start.contentLanguages,
+    all: start.path[0] === "setup",
+    io: {
+      ask: /* @__PURE__ */ __name(async (prompt) => (await import("./prompt-CAQ7QR3U.js")).readSecret(prompt, { input, echo: true }), "ask"),
+      say: /* @__PURE__ */ __name((text) => process.stderr.write(`${text}
+`), "say")
+    }
+  }).catch((error) => {
+    process.stderr.write(`setup questions skipped: ${error instanceof Error ? error.message : String(error)} \u2014 \`${start.command} setup\` asks them again
+`);
+  });
+}, "setupAtStart");
+
+export {
+  asksAtStart,
+  systemLanguage,
+  askSetupQuestions,
+  setupAtStart
+};