@wirecat/cli-template 0.9.0 → 0.11.0

package/dist/bundle/bun-HB6O2TTT.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-Z7MSIRSQ.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/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-KBXOW2ES.js

@@ -0,0 +1,69 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  loadVectorExtension,
+  vectorExtension
+} from "./chunk-QBP7OMN5.js";
+import "./chunk-EFHLQXG6.js";
+import {
+  importFrom
+} from "./chunk-Y5E2WNWB.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/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-2B5U4Z5H.js

@@ -0,0 +1,100 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError
+} from "./chunk-EFHLQXG6.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/node_modules/@wirecat/cli-core/dist/store/driver.js
+var PRAGMAS = `
+  PRAGMA busy_timeout = 5000;
+  PRAGMA journal_mode = WAL;
+  PRAGMA foreign_keys = ON;
+`;
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/node_modules/@wirecat/cli-core/dist/store/sqlite-warning.js
+var SQLITE_WARNING = "SQLite is an experimental feature";
+var quieted = /* @__PURE__ */ new WeakSet();
+var quietSqliteWarning = /* @__PURE__ */ __name((host = process) => {
+  if (quieted.has(host))
+    return;
+  quieted.add(host);
+  const emit = host.emitWarning;
+  host.emitWarning = function(warning, ...rest) {
+    if (isSqliteWarning(warning, rest[0]))
+      return;
+    return Reflect.apply(emit, this, [warning, ...rest]);
+  };
+}, "quietSqliteWarning");
+var isSqliteWarning = /* @__PURE__ */ __name((warning, options) => {
+  const type = typeof options === "string" ? options : options?.type;
+  const name = typeof warning === "string" ? type : warning.name;
+  const message = typeof warning === "string" ? warning : warning.message;
+  return name === "ExperimentalWarning" && message.startsWith(SQLITE_WARNING);
+}, "isSqliteWarning");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/node_modules/@wirecat/cli-core/dist/store/open.js
+var openCache = /* @__PURE__ */ __name(async (path) => {
+  const database = await openFile(path);
+  try {
+    database.exec(PRAGMAS);
+  } catch (error) {
+    database.close();
+    throw error;
+  }
+  return database;
+}, "openCache");
+var openFile = /* @__PURE__ */ __name((path) => "Bun" in globalThis ? openUnderBun(path) : openUnderNode(path), "openFile");
+var openUnderBun = /* @__PURE__ */ __name(async (path) => {
+  const { openWithBunSqlite } = await import("./bun-sqlite-KBXOW2ES.js");
+  return await openWithBunSqlite(path);
+}, "openUnderBun");
+var openUnderNode = /* @__PURE__ */ __name(async (path) => {
+  quietSqliteWarning();
+  const { openWithNodeSqlite } = await import("./node-sqlite-BR7F3BLB.js");
+  return openWithNodeSqlite(path);
+}, "openUnderNode");
+var runtime = /* @__PURE__ */ __name(() => {
+  const bun = globalThis.Bun;
+  return bun ? `Bun ${bun.version}` : `Node ${process.versions.node}`;
+}, "runtime");
+var CAPABILITY_STATEMENTS = [
+  `CREATE VIRTUAL TABLE temp.capability_words USING fts5(a, content = '', contentless_delete = 1,
+     tokenize = 'unicode61 remove_diacritics 2')`,
+  "CREATE VIRTUAL TABLE temp.capability_text USING fts5(a, tokenize = 'trigram')",
+  "DROP TABLE temp.capability_words",
+  "DROP TABLE temp.capability_text"
+];
+var assertStoreCapable = /* @__PURE__ */ __name((database, on = runtime()) => {
+  try {
+    for (const statement of CAPABILITY_STATEMENTS)
+      database.exec(statement);
+  } catch (error) {
+    const version = String(database.prepare("SELECT sqlite_version() AS version").get()?.version);
+    const remedy = on.startsWith("Bun") ? "Run it under Node 22.16 or newer instead" : "Update Node to 22.16 or newer, or run it under Bun";
+    throw new CliError("configuration_error", `the message store needs full-text search that this SQLite (${version}, ${on}) does not have. ${remedy}.`, { sqlite: version, runtime: on, cause: error instanceof Error ? error.message : String(error) });
+  }
+}, "assertStoreCapable");
+var capable;
+var storeCapable = /* @__PURE__ */ __name(() => {
+  capable ??= openCache(":memory:").then((database) => {
+    try {
+      assertStoreCapable(database);
+    } finally {
+      database.close();
+    }
+  });
+  return capable;
+}, "storeCapable");
+
+export {
+  PRAGMAS,
+  quietSqliteWarning,
+  openCache,
+  openFile,
+  CAPABILITY_STATEMENTS,
+  assertStoreCapable,
+  storeCapable
+};

package/dist/bundle/chunk-35KYY65W.js

@@ -0,0 +1,122 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  unit
+} from "./chunk-QKWRL4OD.js";
+import {
+  CliError
+} from "./chunk-EFHLQXG6.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/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
+};