@theclawlab/xdb 1.0.3

package/dist/cli.js

@@ -0,0 +1,2197 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { readFileSync } from "fs";
+import { join as join8, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/commands/col.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/collection-manager.ts
+import { readdir, mkdir, rm, stat, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+
+// src/errors.ts
+var PARAMETER_ERROR = 2;
+var RUNTIME_ERROR = 1;
+var XDBError = class extends Error {
+  constructor(exitCode, message) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "XDBError";
+  }
+};
+function outputError(err) {
+  process.stderr.write(`Error: ${err.message}
+`);
+}
+function handleError(err) {
+  if (err instanceof XDBError) {
+    outputError(err);
+    process.exit(err.exitCode);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  const xdbErr = new XDBError(RUNTIME_ERROR, message);
+  outputError(xdbErr);
+  process.exit(xdbErr.exitCode);
+}
+
+// src/collection-manager.ts
+var CollectionManager = class {
+  constructor(dataRoot) {
+    this.dataRoot = dataRoot;
+    this.collectionsDir = join(dataRoot, "collections");
+  }
+  collectionsDir;
+  /** Ensure the dataRoot and collections directory exist. */
+  async ensureRoot() {
+    await mkdir(this.collectionsDir, { recursive: true });
+  }
+  collectionPath(name) {
+    return join(this.collectionsDir, name);
+  }
+  metaPath(name) {
+    return join(this.collectionPath(name), "collection_meta.json");
+  }
+  /**
+   * Create a new collection directory and write collection_meta.json.
+   * Throws PARAMETER_ERROR if the collection already exists.
+   */
+  async init(name, policy2) {
+    await this.ensureRoot();
+    if (await this.exists(name)) {
+      throw new XDBError(PARAMETER_ERROR, `Collection "${name}" already exists`);
+    }
+    const colPath = this.collectionPath(name);
+    await mkdir(colPath, { recursive: true });
+    const meta = {
+      name,
+      policy: policy2,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeFile(this.metaPath(name), JSON.stringify(meta, null, 2), "utf-8");
+  }
+  /**
+   * Scan the collections directory and return info for each collection.
+   */
+  async list() {
+    await this.ensureRoot();
+    let entries;
+    try {
+      entries = await readdir(this.collectionsDir);
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+      const colPath = this.collectionPath(entry);
+      try {
+        const s = await stat(colPath);
+        if (!s.isDirectory()) continue;
+        const meta = await this.load(entry);
+        const sizeBytes = await this.calcDirSize(colPath);
+        const recordCount = await this.countRecords(colPath, meta.policy);
+        results.push({
+          name: meta.name,
+          policy: `${meta.policy.main}/${meta.policy.minor}`,
+          recordCount,
+          sizeBytes,
+          ...meta.embeddingDimension !== void 0 ? { embeddingDimension: meta.embeddingDimension } : {}
+        });
+      } catch {
+        continue;
+      }
+    }
+    return results;
+  }
+  /**
+   * Count records in a collection by opening the appropriate engine.
+   * Prefers SQLite (cheaper to open) when available, falls back to LanceDB.
+   */
+  async countRecords(colPath, policy2) {
+    const hasSqlite = policy2.main === "hybrid" || policy2.main === "relational";
+    const hasLance = policy2.main === "hybrid" || policy2.main === "vector";
+    if (hasSqlite) {
+      try {
+        const { default: Database2 } = await import("better-sqlite3");
+        const dbPath = join(colPath, "relational.db");
+        try {
+          await stat(dbPath);
+        } catch {
+          return 0;
+        }
+        const db = new Database2(dbPath, { readonly: true });
+        try {
+          const row = db.prepare("SELECT COUNT(*) as cnt FROM records").get();
+          return row?.cnt ?? 0;
+        } catch {
+          return 0;
+        } finally {
+          db.close();
+        }
+      } catch {
+        return 0;
+      }
+    }
+    if (hasLance) {
+      try {
+        const lancedb2 = await import("@lancedb/lancedb");
+        const dbPath = join(colPath, "vector.lance");
+        try {
+          await stat(dbPath);
+        } catch {
+          return 0;
+        }
+        const db = await lancedb2.connect(dbPath);
+        const tableNames = await db.tableNames();
+        if (tableNames.includes("data")) {
+          const table = await db.openTable("data");
+          const count = await table.countRows();
+          table.close();
+          db.close();
+          return count;
+        }
+        db.close();
+        return 0;
+      } catch {
+        return 0;
+      }
+    }
+    return 0;
+  }
+  /**
+   * Recursively delete a collection directory.
+   * Throws PARAMETER_ERROR if the collection doesn't exist.
+   */
+  async remove(name) {
+    await this.ensureRoot();
+    if (!await this.exists(name)) {
+      throw new XDBError(PARAMETER_ERROR, `Collection "${name}" does not exist`);
+    }
+    await rm(this.collectionPath(name), { recursive: true, force: true });
+  }
+  /**
+   * Read and parse collection_meta.json for a collection.
+   * Throws PARAMETER_ERROR if the collection doesn't exist.
+   */
+  async load(name) {
+    if (!await this.exists(name)) {
+      throw new XDBError(PARAMETER_ERROR, `Collection "${name}" does not exist`);
+    }
+    try {
+      const raw = await readFile(this.metaPath(name), "utf-8");
+      return JSON.parse(raw);
+    } catch (err) {
+      if (err instanceof XDBError) throw err;
+      throw new XDBError(RUNTIME_ERROR, `Failed to read metadata for collection "${name}": ${err.message}`);
+    }
+  }
+  /**
+   * Check if a collection directory exists.
+   */
+  async exists(name) {
+    try {
+      const s = await stat(this.collectionPath(name));
+      return s.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Update the embeddingDimension in collection_meta.json.
+   * Only writes if the current meta has no embeddingDimension set.
+   * Throws PARAMETER_ERROR if dimension conflicts with existing value.
+   */
+  async recordEmbeddingDimension(name, dimension) {
+    const meta = await this.load(name);
+    if (meta.embeddingDimension !== void 0) {
+      if (meta.embeddingDimension !== dimension) {
+        throw new XDBError(
+          PARAMETER_ERROR,
+          `Embedding dimension mismatch for collection "${name}": expected ${meta.embeddingDimension}, got ${dimension}. This usually means the embedding model has changed. Remove and recreate the collection to use a different model.`
+        );
+      }
+      return;
+    }
+    meta.embeddingDimension = dimension;
+    await writeFile(this.metaPath(name), JSON.stringify(meta, null, 2), "utf-8");
+  }
+  /** Calculate total size of all files in a directory (non-recursive for simplicity). */
+  async calcDirSize(dirPath) {
+    let total = 0;
+    try {
+      const entries = await readdir(dirPath);
+      for (const entry of entries) {
+        const entryPath = join(dirPath, entry);
+        const s = await stat(entryPath);
+        if (s.isFile()) {
+          total += s.size;
+        } else if (s.isDirectory()) {
+          total += await this.calcDirSize(entryPath);
+        }
+      }
+    } catch {
+    }
+    return total;
+  }
+};
+
+// src/policy-registry.ts
+var BUILTIN_POLICIES = {
+  "hybrid/knowledge-base": {
+    main: "hybrid",
+    minor: "knowledge-base",
+    fields: { content: { findCaps: ["similar", "match"] } },
+    autoIndex: true
+  },
+  "relational/structured-logs": {
+    main: "relational",
+    minor: "structured-logs",
+    fields: {},
+    autoIndex: true
+  },
+  "relational/simple-kv": {
+    main: "relational",
+    minor: "simple-kv",
+    fields: {},
+    autoIndex: false
+  },
+  "vector/feature-store": {
+    main: "vector",
+    minor: "feature-store",
+    fields: { tensor: { findCaps: ["similar"] } },
+    autoIndex: false
+  }
+};
+var DEFAULT_MINORS = {
+  hybrid: "knowledge-base",
+  relational: "structured-logs",
+  vector: "feature-store"
+};
+var ALLOWED_CAPS = {
+  hybrid: /* @__PURE__ */ new Set(["similar", "match"]),
+  relational: /* @__PURE__ */ new Set(["match"]),
+  vector: /* @__PURE__ */ new Set(["similar"])
+};
+var PolicyRegistry = class {
+  /**
+   * Resolve a policy string like "hybrid/knowledge-base" or just "hybrid"
+   * into a full PolicyConfig. Optionally deep-merge params overrides.
+   */
+  resolve(policyStr, params) {
+    let fullName = policyStr;
+    if (!policyStr.includes("/")) {
+      const defaultMinor = DEFAULT_MINORS[policyStr];
+      if (!defaultMinor) {
+        const available = Object.keys(BUILTIN_POLICIES).join(", ");
+        throw new XDBError(PARAMETER_ERROR, `Unknown policy "${policyStr}". Available policies: ${available}`);
+      }
+      fullName = `${policyStr}/${defaultMinor}`;
+    }
+    const builtin = BUILTIN_POLICIES[fullName];
+    if (!builtin) {
+      const available = Object.keys(BUILTIN_POLICIES).join(", ");
+      throw new XDBError(PARAMETER_ERROR, `Unknown policy "${fullName}". Available policies: ${available}`);
+    }
+    const config2 = {
+      main: builtin.main,
+      minor: builtin.minor,
+      fields: deepCloneFields(builtin.fields),
+      ...builtin.autoIndex !== void 0 ? { autoIndex: builtin.autoIndex } : {}
+    };
+    if (params) {
+      if (params.fields && typeof params.fields === "object") {
+        const paramFields = params.fields;
+        for (const [fieldName, fieldConfig] of Object.entries(paramFields)) {
+          config2.fields[fieldName] = { findCaps: [...fieldConfig.findCaps] };
+        }
+      }
+      if (params.autoIndex !== void 0) {
+        config2.autoIndex = params.autoIndex;
+      }
+    }
+    return config2;
+  }
+  /**
+   * Validate that a PolicyConfig's findCaps are compatible with its main engine type.
+   * Throws XDBError(PARAMETER_ERROR) if validation fails.
+   */
+  validate(config2) {
+    const allowed = ALLOWED_CAPS[config2.main];
+    if (!allowed) {
+      throw new XDBError(PARAMETER_ERROR, `Unknown main engine type "${config2.main}"`);
+    }
+    for (const [fieldName, fieldConfig] of Object.entries(config2.fields)) {
+      for (const cap of fieldConfig.findCaps) {
+        if (!allowed.has(cap)) {
+          throw new XDBError(
+            PARAMETER_ERROR,
+            `findCaps "${cap}" is not compatible with engine type "${config2.main}" (field: "${fieldName}")`
+          );
+        }
+      }
+    }
+  }
+  /** List all available built-in policies. */
+  listPolicies() {
+    return Object.values(BUILTIN_POLICIES).map((p) => ({
+      main: p.main,
+      minor: p.minor,
+      fields: deepCloneFields(p.fields),
+      ...p.autoIndex !== void 0 ? { autoIndex: p.autoIndex } : {}
+    }));
+  }
+};
+function deepCloneFields(fields) {
+  const result = {};
+  for (const [key, value] of Object.entries(fields)) {
+    result[key] = { findCaps: [...value.findCaps] };
+  }
+  return result;
+}
+
+// src/commands/col.ts
+function getDataRoot() {
+  return join2(homedir(), ".local", "share", "xdb");
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function registerColCommands(col2) {
+  col2.command("init <name>").description("Initialize a new collection").requiredOption("--policy <policy>", "Policy name (main/minor format)").option("--params <json>", "Custom parameters as JSON to override policy defaults").action(async (name, opts) => {
+    try {
+      const registry = new PolicyRegistry();
+      let params;
+      if (opts.params) {
+        try {
+          params = JSON.parse(opts.params);
+        } catch {
+          throw new XDBError(PARAMETER_ERROR, `Invalid JSON for --params: ${opts.params}`);
+        }
+      }
+      const config2 = registry.resolve(opts.policy, params);
+      registry.validate(config2);
+      const manager = new CollectionManager(getDataRoot());
+      await manager.init(name, config2);
+      process.stderr.write(`Collection "${name}" created (policy: ${config2.main}/${config2.minor})
+`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  col2.command("list").description("List all collections").option("--json", "Output as JSON array").action(async (opts) => {
+    try {
+      const manager = new CollectionManager(getDataRoot());
+      const collections = await manager.list();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(collections) + "\n");
+        return;
+      }
+      if (collections.length === 0) {
+        process.stderr.write("No collections found.\n");
+        return;
+      }
+      for (const info of collections) {
+        const dim = info.embeddingDimension ? `, dim=${info.embeddingDimension}` : "";
+        process.stdout.write(
+          `${info.name}  policy=${info.policy}  records=${info.recordCount}  size=${formatBytes(info.sizeBytes)}${dim}
+`
+        );
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  col2.command("info <name>").description("Show detailed information about a collection").option("--json", "Output as JSON").action(async (name, opts) => {
+    try {
+      const manager = new CollectionManager(getDataRoot());
+      const meta = await manager.load(name);
+      const collections = await manager.list();
+      const stats = collections.find((c) => c.name === name);
+      const info = {
+        name: meta.name,
+        createdAt: meta.createdAt,
+        policy: `${meta.policy.main}/${meta.policy.minor}`,
+        engines: meta.policy.main,
+        autoIndex: meta.policy.autoIndex ?? false,
+        fields: meta.policy.fields,
+        embeddingDimension: meta.embeddingDimension ?? null,
+        recordCount: stats?.recordCount ?? 0,
+        sizeBytes: stats?.sizeBytes ?? 0,
+        path: join2(getDataRoot(), "collections", name)
+      };
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(info) + "\n");
+        return;
+      }
+      process.stdout.write(`name:       ${info.name}
+`);
+      process.stdout.write(`createdAt:  ${info.createdAt}
+`);
+      process.stdout.write(`path:       ${info.path}
+`);
+      process.stdout.write(`policy:     ${info.policy}
+`);
+      process.stdout.write(`engines:    ${info.engines}
+`);
+      process.stdout.write(`autoIndex:  ${info.autoIndex}
+`);
+      process.stdout.write(`records:    ${info.recordCount}
+`);
+      process.stdout.write(`size:       ${formatBytes(info.sizeBytes)}
+`);
+      if (info.embeddingDimension) {
+        process.stdout.write(`embedDim:   ${info.embeddingDimension}
+`);
+      }
+      const fieldNames = Object.keys(info.fields);
+      if (fieldNames.length > 0) {
+        process.stdout.write(`fields:
+`);
+        for (const [f, cfg] of Object.entries(info.fields)) {
+          process.stdout.write(`  ${f}  findCaps=[${cfg.findCaps.join(", ")}]
+`);
+        }
+      } else {
+        process.stdout.write(`fields:     (none)
+`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  col2.command("rm <name>").description("Remove a collection").action(async (name) => {
+    try {
+      const manager = new CollectionManager(getDataRoot());
+      await manager.remove(name);
+      process.stderr.write(`Collection "${name}" removed.
+`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/policy.ts
+var ENGINE_DESC = {
+  hybrid: "LanceDB + SQLite",
+  relational: "SQLite",
+  vector: "LanceDB"
+};
+function registerPolicyCommands(policy2) {
+  policy2.command("list").description("List all available built-in policies").option("--json", "Output as JSON array").action((opts) => {
+    process.stderr.write("[Deprecated] xdb policy list is deprecated. Use 'xdb config' instead.\n");
+    try {
+      const registry = new PolicyRegistry();
+      const policies = registry.listPolicies();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(policies) + "\n");
+        return;
+      }
+      for (const p of policies) {
+        const name = `${p.main}/${p.minor}`;
+        const engines = ENGINE_DESC[p.main] ?? p.main;
+        const fieldNames = Object.keys(p.fields);
+        const fieldsStr = fieldNames.length > 0 ? fieldNames.map((f) => {
+          const caps = p.fields[f].findCaps.join(", ");
+          return `${f} [${caps}]`;
+        }).join("; ") : "(none)";
+        const autoIdx = p.autoIndex ? "yes" : "no";
+        process.stdout.write(`${name}
+`);
+        process.stdout.write(`  engines:    ${engines}
+`);
+        process.stdout.write(`  fields:     ${fieldsStr}
+`);
+        process.stdout.write(`  autoIndex:  ${autoIdx}
+`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/put.ts
+import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
+
+// src/embedding-client.ts
+var PROVIDER_DEFAULT_BASE_URLS = {
+  openai: "https://api.openai.com"
+};
+var EmbeddingClient = class _EmbeddingClient {
+  endpoint;
+  apiKey;
+  model;
+  isAzure;
+  constructor(config2) {
+    this.apiKey = config2.apiKey;
+    this.model = config2.model;
+    const apiType = config2.api ?? config2.provider;
+    this.isAzure = apiType === "azure-openai-responses" || apiType === "azure-openai";
+    this.endpoint = this.isAzure ? _EmbeddingClient.resolveAzureEndpoint(config2.baseUrl, config2.model, config2.providerOptions) : _EmbeddingClient.resolveEndpoint(config2.provider, config2.baseUrl);
+  }
+  /**
+   * Resolve the full embeddings API endpoint URL.
+   * If baseUrl is provided, use it; otherwise fall back to the provider default.
+   */
+  static resolveEndpoint(provider, baseUrl) {
+    const base = baseUrl ?? (Object.hasOwn(PROVIDER_DEFAULT_BASE_URLS, provider) ? PROVIDER_DEFAULT_BASE_URLS[provider] : void 0);
+    if (!base) {
+      throw new XDBError(
+        PARAMETER_ERROR,
+        `No base URL configured for provider "${provider}". Please specify a baseUrl.`
+      );
+    }
+    return `${base.replace(/\/+$/, "")}/v1/embeddings`;
+  }
+  /**
+   * Resolve the Azure OpenAI embeddings endpoint URL.
+   * Azure format: {baseUrl}/openai/deployments/{deployment}/embeddings?api-version={version}
+   */
+  static resolveAzureEndpoint(baseUrl, model, providerOptions) {
+    if (!baseUrl) {
+      throw new XDBError(
+        PARAMETER_ERROR,
+        "Azure OpenAI requires a baseUrl. Please specify a baseUrl."
+      );
+    }
+    const deployment = model ?? providerOptions?.azureDeploymentName;
+    if (!deployment) {
+      throw new XDBError(
+        PARAMETER_ERROR,
+        "Azure OpenAI requires a deployment name. Specify a model or set providerOptions.azureDeploymentName."
+      );
+    }
+    const apiVersion = providerOptions?.azureApiVersion;
+    const resolvedVersion = apiVersion && /^\d{4}-\d{2}-\d{2}/.test(apiVersion) ? apiVersion : "2024-06-01";
+    const resourceBase = baseUrl.replace(/\/openai\/v1\/?$/, "").replace(/\/+$/, "");
+    return `${resourceBase}/openai/deployments/${deployment}/embeddings?api-version=${resolvedVersion}`;
+  }
+  /**
+   * Call the embedding API for the given texts.
+   */
+  async embed(request) {
+    const body = JSON.stringify({
+      model: request.model,
+      input: request.texts
+    });
+    let response;
+    try {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.isAzure) {
+        headers["api-key"] = this.apiKey;
+      } else {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+      }
+      response = await fetch(this.endpoint, {
+        method: "POST",
+        headers,
+        body
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new XDBError(
+        RUNTIME_ERROR,
+        `Network error calling embedding API: ${message}`
+      );
+    }
+    if (!response.ok) {
+      let detail = "";
+      try {
+        const errorBody = await response.text();
+        detail = errorBody;
+      } catch {
+      }
+      throw new XDBError(
+        RUNTIME_ERROR,
+        `Embedding API error (${response.status}): ${detail || response.statusText}`
+      );
+    }
+    const json = await response.json();
+    const sorted = [...json.data].sort((a, b) => a.index - b.index);
+    return {
+      embeddings: sorted.map((d) => d.embedding),
+      model: json.model,
+      usage: {
+        promptTokens: json.usage.prompt_tokens,
+        totalTokens: json.usage.total_tokens
+      }
+    };
+  }
+};
+
+// src/config-manager.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+var DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".config", "xdb", "default.json");
+var PAI_CONFIG_PATH = path.join(os.homedir(), ".config", "pai", "default.json");
+var EMPTY_CONFIG = {
+  providers: []
+};
+var XdbConfigManager = class {
+  configPath;
+  paiConfigPath;
+  constructor(configPath, paiConfigPath) {
+    this.configPath = configPath ?? DEFAULT_CONFIG_PATH;
+    this.paiConfigPath = paiConfigPath ?? PAI_CONFIG_PATH;
+  }
+  async load() {
+    let raw;
+    try {
+      raw = await fs.readFile(this.configPath, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { ...EMPTY_CONFIG, providers: [] };
+      }
+      throw new XDBError(RUNTIME_ERROR, `Failed to read config file: ${err.message}`);
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed.providers)) {
+        parsed.providers = [];
+      }
+      return parsed;
+    } catch {
+      throw new XDBError(RUNTIME_ERROR, `Config file contains invalid JSON: ${this.configPath}`);
+    }
+  }
+  async save(config2) {
+    const dir = path.dirname(this.configPath);
+    try {
+      await fs.mkdir(dir, { recursive: true });
+    } catch (err) {
+      throw new XDBError(RUNTIME_ERROR, `Failed to create config directory: ${err.message}`);
+    }
+    try {
+      await fs.writeFile(this.configPath, JSON.stringify(config2, null, 2), "utf-8");
+    } catch (err) {
+      throw new XDBError(RUNTIME_ERROR, `Failed to write config file: ${err.message}`);
+    }
+  }
+  /**
+   * Resolve API key for a provider.
+   * Priority: XDB_<PROVIDER>_API_KEY env var > config file apiKey
+   */
+  async resolveApiKey(providerName) {
+    const envVarName = `XDB_${providerName.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+    const envValue = process.env[envVarName];
+    if (envValue) {
+      return envValue;
+    }
+    const config2 = await this.load();
+    const providerConfig = config2.providers.find((p) => p.name === providerName);
+    if (providerConfig?.apiKey) {
+      return providerConfig.apiKey;
+    }
+    throw new XDBError(
+      PARAMETER_ERROR,
+      `No API key found for provider "${providerName}". Set the ${envVarName} environment variable or run: xdb config embed --set-key <apiKey>`
+    );
+  }
+  /**
+   * Try to load pai's config as an embed fallback.
+   * Returns null if pai config doesn't exist or has no embed settings.
+   */
+  async loadPaiFallback() {
+    let raw;
+    try {
+      raw = await fs.readFile(this.paiConfigPath, "utf-8");
+    } catch {
+      return null;
+    }
+    let pai;
+    try {
+      pai = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+    const provider = pai.defaultEmbedProvider;
+    const model = pai.defaultEmbedModel;
+    if (!provider || !model) return null;
+    const paiProvider = pai.providers?.find((p) => p.name === provider);
+    if (!paiProvider) return null;
+    if (!paiProvider.apiKey) return null;
+    const providerConfig = {
+      name: paiProvider.name,
+      apiKey: paiProvider.apiKey,
+      ...paiProvider.baseUrl !== void 0 && { baseUrl: paiProvider.baseUrl },
+      ...paiProvider.api !== void 0 && { api: paiProvider.api },
+      ...paiProvider.providerOptions !== void 0 && { providerOptions: paiProvider.providerOptions }
+    };
+    return { provider, model, providerConfig, apiKey: paiProvider.apiKey };
+  }
+  /**
+   * Resolve the current embed configuration (provider + model + providerConfig + apiKey).
+   * Priority:
+   *   1. xdb's own config (~/.config/xdb/default.json or XDB_* env vars)
+   *   2. pai's config (~/.config/pai/default.json) as fallback
+   * Throws XDBError(PARAMETER_ERROR) if neither source has embed config.
+   */
+  async resolveEmbedConfig() {
+    const config2 = await this.load();
+    const provider = config2.defaultEmbedProvider;
+    const model = config2.defaultEmbedModel;
+    if (provider && model) {
+      const providerConfig = config2.providers.find((p) => p.name === provider) ?? { name: provider };
+      const apiKey = await this.resolveApiKey(provider);
+      return { provider, model, providerConfig, apiKey };
+    }
+    const paiFallback = await this.loadPaiFallback();
+    if (paiFallback) {
+      return paiFallback;
+    }
+    throw new XDBError(
+      PARAMETER_ERROR,
+      "No embed provider configured. Run: xdb config embed --set-provider <name>\nOr configure pai embed settings: pai model default --embed-provider <name> --embed-model <model>"
+    );
+  }
+};
+
+// src/embedder.ts
+var Embedder = class {
+  configManager;
+  constructor(configManager) {
+    this.configManager = configManager ?? new XdbConfigManager();
+  }
+  /**
+   * Embed a single text string into a vector.
+   * Returns number[] directly (no hex encoding).
+   */
+  async embed(text) {
+    const { model, providerConfig, apiKey } = await this.configManager.resolveEmbedConfig();
+    const client = new EmbeddingClient({
+      provider: providerConfig.name,
+      apiKey,
+      model,
+      ...providerConfig.baseUrl !== void 0 ? { baseUrl: providerConfig.baseUrl } : {},
+      ...providerConfig.api !== void 0 ? { api: providerConfig.api } : {},
+      ...providerConfig.providerOptions !== void 0 ? { providerOptions: providerConfig.providerOptions } : {}
+    });
+    try {
+      const response = await client.embed({ texts: [text], model });
+      return response.embeddings[0];
+    } catch (err) {
+      if (err instanceof XDBError) throw err;
+      throw new XDBError(RUNTIME_ERROR, `Embedding failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  /**
+   * Embed multiple texts in a single batch call.
+   * Returns number[][] directly (no hex encoding).
+   */
+  async embedBatch(texts) {
+    const { model, providerConfig, apiKey } = await this.configManager.resolveEmbedConfig();
+    const client = new EmbeddingClient({
+      provider: providerConfig.name,
+      apiKey,
+      model,
+      ...providerConfig.baseUrl !== void 0 ? { baseUrl: providerConfig.baseUrl } : {},
+      ...providerConfig.api !== void 0 ? { api: providerConfig.api } : {},
+      ...providerConfig.providerOptions !== void 0 ? { providerOptions: providerConfig.providerOptions } : {}
+    });
+    try {
+      const response = await client.embed({ texts, model });
+      return response.embeddings;
+    } catch (err) {
+      if (err instanceof XDBError) throw err;
+      throw new XDBError(RUNTIME_ERROR, `Embedding failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+
+// src/data-writer.ts
+import { v4 as uuidv4 } from "uuid";
+var DataWriter = class {
+  constructor(policy2, embedder, lanceEngine, sqliteEngine, onEmbeddingDimension) {
+    this.policy = policy2;
+    this.embedder = embedder;
+    this.lanceEngine = lanceEngine;
+    this.sqliteEngine = sqliteEngine;
+    this.onEmbeddingDimension = onEmbeddingDimension;
+  }
+  dimensionRecorded = false;
+  /** Report embedding dimension on first encounter */
+  async reportDimension(vector) {
+    if (this.dimensionRecorded || !this.onEmbeddingDimension) return;
+    this.dimensionRecorded = true;
+    await this.onEmbeddingDimension(vector.length);
+  }
+  /**
+   * Write a single record. Auto-generates UUID if no `id` field present.
+   * Routes data to engines based on Policy findCaps configuration.
+   */
+  async write(record) {
+    this.validateRecord(record);
+    if (record.id === void 0 || record.id === null) {
+      record = { ...record, id: uuidv4() };
+    }
+    const result = { inserted: 0, updated: 0, errors: 0 };
+    const hasSimilarFields = this.getSimilarFields().length > 0;
+    const needsSqlite3 = this.needsSqliteWrite();
+    if (hasSimilarFields && this.lanceEngine) {
+      const vectorRecord = await this.buildVectorRecord(record);
+      const lanceResult = await this.lanceEngine.upsert([vectorRecord]);
+      result.inserted += lanceResult.inserted;
+      result.updated += lanceResult.updated;
+    }
+    if (needsSqlite3 && this.sqliteEngine) {
+      const sqliteResult = this.sqliteEngine.upsert([record]);
+      if (!hasSimilarFields || !this.lanceEngine) {
+        result.inserted += sqliteResult.inserted;
+        result.updated += sqliteResult.updated;
+      }
+    }
+    if ((!hasSimilarFields || !this.lanceEngine) && (!needsSqlite3 || !this.sqliteEngine)) {
+      result.inserted = 1;
+    }
+    return result;
+  }
+  /**
+   * Batch write with transaction optimization and error tolerance.
+   * Failed records are skipped with a warning to stderr.
+   */
+  async writeBatch(records) {
+    const result = { inserted: 0, updated: 0, errors: 0 };
+    const prepared = [];
+    const validIndices = [];
+    for (let i = 0; i < records.length; i++) {
+      try {
+        this.validateRecord(records[i]);
+        let rec = records[i];
+        if (rec.id === void 0 || rec.id === null) {
+          rec = { ...rec, id: uuidv4() };
+        }
+        prepared.push(rec);
+        validIndices.push(i);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Warning: Line ${i + 1}: ${msg}
+`);
+        result.errors++;
+      }
+    }
+    if (prepared.length === 0) {
+      return result;
+    }
+    const hasSimilarFields = this.getSimilarFields().length > 0;
+    const needsSqlite3 = this.needsSqliteWrite();
+    if (hasSimilarFields && this.lanceEngine) {
+      const vectorRecords = [];
+      const similarFields = this.getSimilarFields();
+      const textsPerField = /* @__PURE__ */ new Map();
+      for (const field of similarFields) {
+        textsPerField.set(field, prepared.map((r) => String(r[field] ?? "")));
+      }
+      const vectorsPerField = /* @__PURE__ */ new Map();
+      for (const [field, texts] of textsPerField) {
+        const vectors = await this.embedder.embedBatch(texts);
+        if (vectors.length > 0) {
+          await this.reportDimension(vectors[0]);
+        }
+        vectorsPerField.set(field, vectors);
+      }
+      for (let i = 0; i < prepared.length; i++) {
+        const rec = { ...prepared[i] };
+        for (const [field, vectors] of vectorsPerField) {
+          rec[`${field}_vector`] = new Float32Array(vectors[i]);
+        }
+        vectorRecords.push(rec);
+      }
+      try {
+        const lanceResult = await this.lanceEngine.upsert(vectorRecords);
+        result.inserted += lanceResult.inserted;
+        result.updated += lanceResult.updated;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Warning: LanceDB batch write failed: ${msg}
+`);
+        result.errors += prepared.length;
+        if (needsSqlite3 && this.sqliteEngine) {
+          const sqliteResult = this.sqliteEngine.batchUpsert(prepared);
+          void sqliteResult;
+        }
+        return result;
+      }
+    }
+    if (needsSqlite3 && this.sqliteEngine) {
+      const sqliteResult = this.sqliteEngine.batchUpsert(prepared);
+      if (!hasSimilarFields || !this.lanceEngine) {
+        result.inserted += sqliteResult.inserted;
+        result.updated += sqliteResult.updated;
+      }
+      result.errors += sqliteResult.errors;
+    }
+    return result;
+  }
+  /** Get field names that have 'similar' findCaps */
+  getSimilarFields() {
+    return Object.entries(this.policy.fields).filter(([, cfg]) => cfg.findCaps.includes("similar")).map(([name]) => name);
+  }
+  /** Check if SQLite write is needed based on policy */
+  needsSqliteWrite() {
+    const hasMatchFields = Object.values(this.policy.fields).some((cfg) => cfg.findCaps.includes("match"));
+    return hasMatchFields || !!this.policy.autoIndex;
+  }
+  /** Validate that a record is a valid object */
+  validateRecord(record) {
+    if (record === null || record === void 0 || typeof record !== "object" || Array.isArray(record)) {
+      throw new XDBError(PARAMETER_ERROR, "Invalid input: expected a JSON object");
+    }
+  }
+  /** Build a record with vector fields for LanceDB */
+  async buildVectorRecord(record) {
+    const similarFields = this.getSimilarFields();
+    const vectorRecord = { ...record };
+    for (const field of similarFields) {
+      const text = String(record[field] ?? "");
+      const vector = await this.embedder.embed(text);
+      await this.reportDimension(vector);
+      vectorRecord[`${field}_vector`] = new Float32Array(vector);
+    }
+    return vectorRecord;
+  }
+};
+
+// src/engines/lancedb-engine.ts
+import * as lancedb from "@lancedb/lancedb";
+import { join as join4 } from "path";
+var DEFAULT_TABLE_NAME = "data";
+var LanceDBEngine = class _LanceDBEngine {
+  db;
+  table;
+  constructor(db, table) {
+    this.db = db;
+    this.table = table;
+  }
+  /**
+   * Open or create a LanceDB connection at `<collectionPath>/vector.lance/`.
+   * If the table does not exist, it will be created on first upsert.
+   */
+  static async open(collectionPath, tableName) {
+    const name = tableName ?? DEFAULT_TABLE_NAME;
+    try {
+      const dbPath = join4(collectionPath, "vector.lance");
+      const db = await lancedb.connect(dbPath);
+      let table;
+      const tableNames = await db.tableNames();
+      if (tableNames.includes(name)) {
+        table = await db.openTable(name);
+      } else {
+        return new LanceDBEngineDeferred(db, name);
+      }
+      return new _LanceDBEngine(db, table);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new XDBError(RUNTIME_ERROR, `Failed to open LanceDB: ${msg}`);
+    }
+  }
+  /**
+   * Write records containing vector fields, executing upsert (merge insert on "id").
+   * Records should contain an `id` field and at least one vector field (array of numbers).
+   */
+  async upsert(records) {
+    if (records.length === 0) {
+      return { inserted: 0, updated: 0 };
+    }
+    try {
+      const countBefore = await this.table.countRows();
+      const arrowTable = _LanceDBEngine.toArrowTable(records);
+      await this.table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(arrowTable);
+      const countAfter = await this.table.countRows();
+      const netNew = countAfter - countBefore;
+      const updated = records.length - netNew;
+      return { inserted: netNew, updated };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new XDBError(RUNTIME_ERROR, `LanceDB upsert failed: ${msg}`);
+    }
+  }
+  /**
+   * Convert records with Float32Array fields into a proper Arrow Table.
+   * Detects Float32Array fields, registers them as vectorColumns, and
+   * uses makeArrowTable to create FixedSizeList<Float32> columns.
+   * If no Float32Array fields are found, returns records as-is for default handling.
+   */
+  static toArrowTable(records) {
+    const vectorColumnNames = /* @__PURE__ */ new Set();
+    for (const rec of records) {
+      for (const [key, value] of Object.entries(rec)) {
+        if (value instanceof Float32Array) {
+          vectorColumnNames.add(key);
+        }
+      }
+      if (vectorColumnNames.size > 0) break;
+    }
+    if (vectorColumnNames.size === 0) {
+      return records;
+    }
+    const vectorColumns = {};
+    for (const name of vectorColumnNames) {
+      vectorColumns[name] = new lancedb.VectorColumnOptions();
+    }
+    const converted = records.map((rec) => {
+      const out = {};
+      for (const [key, value] of Object.entries(rec)) {
+        out[key] = value instanceof Float32Array ? Array.from(value) : value;
+      }
+      return out;
+    });
+    return lancedb.makeArrowTable(converted, { vectorColumns });
+  }
+  /**
+   * Nearest neighbor vector search with optional pre-filter.
+   */
+  async vectorSearch(queryVector, options) {
+    try {
+      let query = this.table.vectorSearch(queryVector).column(options.column ?? "vector").limit(options.limit);
+      if (options.filter) {
+        query = query.where(options.filter);
+      }
+      const results = await query.toArray();
+      return results.map((row) => {
+        const data = {};
+        for (const [key, value] of Object.entries(row)) {
+          if (key === "_distance") continue;
+          if (key.endsWith("_vector")) continue;
+          data[key] = value;
+        }
+        const result = {
+          data,
+          _engine: "lancedb"
+        };
+        if (row._distance != null) {
+          result._score = 1 - row._distance / 2;
+        }
+        return result;
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new XDBError(RUNTIME_ERROR, `LanceDB vector search failed: ${msg}`);
+    }
+  }
+  /**
+   * Scalar filter query (no vector search).
+   */
+  async filterSearch(filter, limit) {
+    try {
+      const results = await this.table.query().where(filter).limit(limit).toArray();
+      return results.map((row) => {
+        const data = {};
+        for (const [key, value] of Object.entries(row)) {
+          if (key.endsWith("_vector")) continue;
+          data[key] = value;
+        }
+        return {
+          data,
+          _engine: "lancedb"
+        };
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new XDBError(RUNTIME_ERROR, `LanceDB filter search failed: ${msg}`);
+    }
+  }
+  /**
+   * Count total rows in the table.
+   */
+  async countRows() {
+    return this.table.countRows();
+  }
+  /**
+   * Close the database connection.
+   */
+  async close() {
+    this.table.close();
+    this.db.close();
+  }
+};
+var LanceDBEngineDeferred = class extends LanceDBEngine {
+  deferredDb;
+  tableName;
+  initialized = false;
+  constructor(db, tableName) {
+    super(db, void 0);
+    this.deferredDb = db;
+    this.tableName = tableName;
+  }
+  async ensureTable(records) {
+    if (this.initialized) {
+      return this.table;
+    }
+    if (!records || records.length === 0) {
+      throw new XDBError(RUNTIME_ERROR, "LanceDB table does not exist yet. Write data first.");
+    }
+    const data = LanceDBEngine.toArrowTable(records);
+    const table = await this.deferredDb.createTable(this.tableName, data);
+    this.table = table;
+    this.initialized = true;
+    return table;
+  }
+  async upsert(records) {
+    if (records.length === 0) {
+      return { inserted: 0, updated: 0 };
+    }
+    if (!this.initialized) {
+      try {
+        await this.ensureTable(records);
+        return { inserted: records.length, updated: 0 };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new XDBError(RUNTIME_ERROR, `LanceDB upsert failed: ${msg}`);
+      }
+    }
+    return super.upsert(records);
+  }
+  async vectorSearch(queryVector, options) {
+    if (!this.initialized) {
+      return [];
+    }
+    return super.vectorSearch(queryVector, options);
+  }
+  async filterSearch(filter, limit) {
+    if (!this.initialized) {
+      return [];
+    }
+    return super.filterSearch(filter, limit);
+  }
+  async countRows() {
+    if (!this.initialized) {
+      return 0;
+    }
+    return super.countRows();
+  }
+  async close() {
+    if (this.initialized) {
+      this.table.close();
+    }
+    this.deferredDb.close();
+  }
+};
+
+// src/engines/sqlite-engine.ts
+import Database from "better-sqlite3";
+import { join as join5 } from "path";
+var SQLiteEngine = class _SQLiteEngine {
+  db;
+  hasFts = false;
+  ftsFields = [];
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Open or create a SQLite database at `<collectionPath>/relational.db`.
+   */
+  static open(collectionPath) {
+    try {
+      const dbPath = join5(collectionPath, "relational.db");
+      const db = new Database(dbPath);
+      db.pragma("journal_mode = WAL");
+      return new _SQLiteEngine(db);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new XDBError(RUNTIME_ERROR, `Failed to open SQLite database: ${msg}`);
+    }
+  }
+  /**
+   * Initialize table schema based on Policy configuration.
+   * Creates the records table and, if the policy has fields with 'match' findCaps,
+   * creates a standalone FTS5 virtual table for full-text search.
+   */
+  initSchema(policy2) {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS records (
+        id TEXT PRIMARY KEY,
+        data JSON NOT NULL
+      );
+    `);
+    this.ftsFields = Object.entries(policy2.fields).filter(([, cfg]) => cfg.findCaps.includes("match")).map(([name]) => name);
+    if (this.ftsFields.length > 0) {
+      const columnDefs = this.ftsFields.join(", ");
+      this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS records_fts USING fts5(
+          id UNINDEXED,
+          ${columnDefs}
+        );
+      `);
+      this.hasFts = true;
+    }
+  }
+  /**
+   * Sync FTS index for a single record: delete old entry then insert new one.
+   */
+  syncFts(record) {
+    if (!this.hasFts) return;
+    const id = String(record.id);
+    this.db.prepare("DELETE FROM records_fts WHERE id = ?").run(id);
+    const cols = ["id", ...this.ftsFields];
+    const placeholders = cols.map(() => "?").join(", ");
+    const values = [id, ...this.ftsFields.map((f) => String(record[f] ?? ""))];
+    this.db.prepare(`INSERT INTO records_fts (${cols.join(", ")}) VALUES (${placeholders})`).run(...values);
+  }
+  /**
+   * Upsert records into the database. Each record must have an `id` field.
+   * Uses INSERT OR REPLACE for upsert semantics.
+   */
+  upsert(records) {
+    let inserted = 0;
+    let updated = 0;
+    const checkStmt = this.db.prepare("SELECT 1 FROM records WHERE id = ?");
+    const upsertStmt = this.db.prepare(
+      "INSERT OR REPLACE INTO records (id, data) VALUES (?, ?)"
+    );
+    const txn = this.db.transaction(() => {
+      for (const record of records) {
+        const id = String(record.id);
+        const exists = checkStmt.get(id);
+        upsertStmt.run(id, JSON.stringify(record));
+        this.syncFts(record);
+        if (exists) {
+          updated++;
+        } else {
+          inserted++;
+        }
+      }
+    });
+    txn();
+    return { inserted, updated };
+  }
+  /**
+   * Batch upsert with error tolerance. Wraps in a transaction.
+   * Individual record failures are counted but don't abort the batch.
+   */
+  batchUpsert(records) {
+    let inserted = 0;
+    let updated = 0;
+    let errors = 0;
+    const checkStmt = this.db.prepare("SELECT 1 FROM records WHERE id = ?");
+    const upsertStmt = this.db.prepare(
+      "INSERT OR REPLACE INTO records (id, data) VALUES (?, ?)"
+    );
+    const txn = this.db.transaction(() => {
+      for (const record of records) {
+        try {
+          const id = String(record.id);
+          const exists = checkStmt.get(id);
+          upsertStmt.run(id, JSON.stringify(record));
+          this.syncFts(record);
+          if (exists) {
+            updated++;
+          } else {
+            inserted++;
+          }
+        } catch {
+          errors++;
+        }
+      }
+    });
+    txn();
+    return { inserted, updated, errors };
+  }
+  /**
+   * Full-text search using FTS5.
+   */
+  ftsSearch(query, limit) {
+    if (!this.hasFts) {
+      return [];
+    }
+    const stmt = this.db.prepare(`
+      SELECT r.data, fts.rank
+      FROM records_fts fts
+      JOIN records r ON r.id = fts.id
+      WHERE records_fts MATCH ?
+      ORDER BY fts.rank
+      LIMIT ?
+    `);
+    const rows = stmt.all(query, limit);
+    return rows.map((row) => ({
+      data: JSON.parse(row.data),
+      _score: -row.rank,
+      // FTS5 rank is negative; negate for positive score
+      _engine: "sqlite"
+    }));
+  }
+  /**
+   * Condition-based filtering using a WHERE clause applied to JSON data.
+   */
+  whereSearch(filter, limit) {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT data FROM records WHERE ${filter} LIMIT ?
+      `);
+      const rows = stmt.all(limit);
+      return rows.map((row) => ({
+        data: JSON.parse(row.data),
+        _engine: "sqlite"
+      }));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new XDBError(RUNTIME_ERROR, `WHERE filter error: ${msg}`);
+    }
+  }
+  /**
+   * Combined FTS + WHERE search.
+   */
+  ftsWhereSearch(query, filter, limit) {
+    if (!this.hasFts) {
+      return [];
+    }
+    try {
+      const stmt = this.db.prepare(`
+        SELECT r.data, fts.rank
+        FROM records_fts fts
+        JOIN records r ON r.id = fts.id
+        WHERE records_fts MATCH ? AND ${filter}
+        ORDER BY fts.rank
+        LIMIT ?
+      `);
+      const rows = stmt.all(query, limit);
+      return rows.map((row) => ({
+        data: JSON.parse(row.data),
+        _score: -row.rank,
+        _engine: "sqlite"
+      }));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new XDBError(RUNTIME_ERROR, `FTS+WHERE filter error: ${msg}`);
+    }
+  }
+  /**
+   * Count total rows in the records table.
+   */
+  countRows() {
+    const row = this.db.prepare("SELECT COUNT(*) as cnt FROM records").get();
+    return row.cnt;
+  }
+  /**
+   * Close the database connection.
+   */
+  close() {
+    this.db.close();
+  }
+};
+
+// src/commands/put.ts
+function getDataRoot2() {
+  return join6(homedir3(), ".local", "share", "xdb");
+}
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    if (process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("error", reject);
+  });
+}
+function parseJsonl(input) {
+  const lines = input.split("\n").filter((l) => l.trim().length > 0);
+  return lines.map((line, i) => {
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("Expected a JSON object");
+      }
+      return parsed;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new XDBError(PARAMETER_ERROR, `Invalid JSON at line ${i + 1}: ${msg}`);
+    }
+  });
+}
+function needsLance(policy2) {
+  return policy2.main === "hybrid" || policy2.main === "vector";
+}
+function needsSqlite(policy2) {
+  return policy2.main === "hybrid" || policy2.main === "relational";
+}
+function registerPutCommand(program2) {
+  program2.command("put <collection> [json]").description("Write data to a collection").option("--batch", "Enable batch write mode for JSONL stdin input").option("--json", "Output stats as JSON (batch mode)").action(async (collection, json, opts) => {
+    try {
+      await executePut(getDataRoot2(), collection, json, !!opts.batch, !!opts.json);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+async function executePut(dataRoot, collection, json, batch, jsonOutput = false) {
+  const manager = new CollectionManager(dataRoot);
+  const meta = await manager.load(collection);
+  const policy2 = meta.policy;
+  const colPath = join6(dataRoot, "collections", collection);
+  let lanceEngine;
+  let sqliteEngine;
+  try {
+    if (needsLance(policy2)) {
+      lanceEngine = await LanceDBEngine.open(colPath);
+    }
+    if (needsSqlite(policy2)) {
+      sqliteEngine = SQLiteEngine.open(colPath);
+      sqliteEngine.initSchema(policy2);
+    }
+    const embedder = new Embedder();
+    const writer = new DataWriter(policy2, embedder, lanceEngine, sqliteEngine, async (dim) => {
+      await manager.recordEmbeddingDimension(collection, dim);
+    });
+    let records;
+    if (json !== void 0) {
+      let parsed;
+      try {
+        parsed = JSON.parse(json);
+      } catch {
+        throw new XDBError(PARAMETER_ERROR, `Invalid JSON: ${json}`);
+      }
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new XDBError(PARAMETER_ERROR, "Invalid input: expected a JSON object");
+      }
+      records = [parsed];
+    } else {
+      const input = await readStdin();
+      if (input.trim().length === 0) {
+        throw new XDBError(PARAMETER_ERROR, "No input provided. Pass JSON as argument or pipe JSONL via stdin.");
+      }
+      records = parseJsonl(input);
+    }
+    if (batch) {
+      const stats = await writer.writeBatch(records);
+      if (jsonOutput) {
+        process.stdout.write(JSON.stringify(stats) + "\n");
+      } else {
+        process.stderr.write(`Batch complete: ${stats.inserted} inserted, ${stats.updated} updated, ${stats.errors} errors
+`);
+      }
+    } else {
+      for (const record of records) {
+        await writer.write(record);
+      }
+      process.stderr.write(`${records.length} record(s) written to "${collection}"
+`);
+    }
+  } finally {
+    if (lanceEngine) await lanceEngine.close();
+    if (sqliteEngine) sqliteEngine.close();
+  }
+}
+
+// src/commands/find.ts
+import { homedir as homedir4 } from "os";
+import { join as join7 } from "path";
+
+// src/data-finder.ts
+var DataFinder = class {
+  constructor(policy2, embedder, lanceEngine, sqliteEngine) {
+    this.policy = policy2;
+    this.embedder = embedder;
+    this.lanceEngine = lanceEngine;
+    this.sqliteEngine = sqliteEngine;
+  }
+  /**
+   * Execute a search based on intent flags and return results.
+   * Routes to the appropriate engine(s) based on --similar/--match/--where.
+   */
+  async find(query, options) {
+    const limit = options.limit ?? 10;
+    if (options.similar) {
+      return this.handleSimilar(query, options.where, limit);
+    }
+    if (options.match) {
+      return this.handleMatch(query, options.where, limit);
+    }
+    if (options.where) {
+      return this.handleWhereOnly(options.where, limit);
+    }
+    throw new XDBError(PARAMETER_ERROR, "No search intent specified. Use --similar, --match, or --where");
+  }
+  /** --similar: vector search via LanceDB */
+  async handleSimilar(query, where, limit) {
+    if (!this.hasCap("similar")) {
+      throw new XDBError(PARAMETER_ERROR, 'This collection does not support semantic search (no fields with "similar" findCaps)');
+    }
+    if (!query) {
+      throw new XDBError(PARAMETER_ERROR, "Query text is required for --similar search");
+    }
+    const similarField = this.getSimilarFields()[0];
+    const column = `${similarField}_vector`;
+    const vector = await this.embedder.embed(query);
+    return this.lanceEngine.vectorSearch(vector, {
+      limit,
+      ...where !== void 0 ? { filter: where } : {},
+      column
+    });
+  }
+  /** --match: full-text search via SQLite FTS5 */
+  async handleMatch(query, where, limit) {
+    if (!this.hasCap("match")) {
+      throw new XDBError(PARAMETER_ERROR, 'This collection does not support full-text search (no fields with "match" findCaps)');
+    }
+    if (!query) {
+      throw new XDBError(PARAMETER_ERROR, "Query text is required for --match search");
+    }
+    if (where) {
+      return this.sqliteEngine.ftsWhereSearch(query, where, limit);
+    }
+    return this.sqliteEngine.ftsSearch(query, limit);
+  }
+  /** --where only (no --similar or --match): prefer SQLite, fallback to LanceDB */
+  async handleWhereOnly(where, limit) {
+    if (this.sqliteEngine) {
+      return this.sqliteEngine.whereSearch(where, limit);
+    }
+    if (this.lanceEngine) {
+      return this.lanceEngine.filterSearch(where, limit);
+    }
+    throw new XDBError(PARAMETER_ERROR, "No search engine available for this collection");
+  }
+  /** Check if the policy has any field with the given findCap */
+  hasCap(cap) {
+    return Object.values(this.policy.fields).some((cfg) => cfg.findCaps.includes(cap));
+  }
+  /** Get field names that have 'similar' findCaps */
+  getSimilarFields() {
+    return Object.entries(this.policy.fields).filter(([, cfg]) => cfg.findCaps.includes("similar")).map(([name]) => name);
+  }
+};
+
+// src/commands/find.ts
+function getDataRoot3() {
+  return join7(homedir4(), ".local", "share", "xdb");
+}
+function readStdin2() {
+  return new Promise((resolve, reject) => {
+    if (process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("error", reject);
+  });
+}
+function needsLance2(policy2) {
+  return policy2.main === "hybrid" || policy2.main === "vector";
+}
+function needsSqlite2(policy2) {
+  return policy2.main === "hybrid" || policy2.main === "relational";
+}
+function registerFindCommand(program2) {
+  program2.command("find <collection> [query]").description("Search data in a collection").option("-s, --similar", "Semantic similarity search").option("-m, --match", "Full-text search").option("-w, --where <sql>", "SQL WHERE clause for filtering").option("-l, --limit <n>", "Maximum number of results", "10").option("--json", "Output as JSONL (machine-readable)").action(
+    async (collection, query, opts) => {
+      try {
+        await executeFind(getDataRoot3(), collection, query, opts);
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  );
+}
+async function executeFind(dataRoot, collection, query, opts) {
+  const manager = new CollectionManager(dataRoot);
+  const meta = await manager.load(collection);
+  const policy2 = meta.policy;
+  const colPath = join7(dataRoot, "collections", collection);
+  const limit = parseInt(opts.limit, 10);
+  if (isNaN(limit) || limit <= 0) {
+    throw new XDBError(PARAMETER_ERROR, `Invalid limit value: ${opts.limit}`);
+  }
+  if (query === void 0 && (opts.similar || opts.match)) {
+    const stdinText = await readStdin2();
+    const trimmed = stdinText.trim();
+    if (trimmed.length > 0) {
+      query = trimmed;
+    }
+  }
+  let lanceEngine;
+  let sqliteEngine;
+  try {
+    if (needsLance2(policy2)) {
+      lanceEngine = await LanceDBEngine.open(colPath);
+    }
+    if (needsSqlite2(policy2)) {
+      sqliteEngine = SQLiteEngine.open(colPath);
+      sqliteEngine.initSchema(policy2);
+    }
+    const embedder = new Embedder();
+    const finder = new DataFinder(policy2, embedder, lanceEngine, sqliteEngine);
+    const results = await finder.find(query, {
+      ...opts.similar !== void 0 ? { similar: opts.similar } : {},
+      ...opts.match !== void 0 ? { match: opts.match } : {},
+      ...opts.where !== void 0 ? { where: opts.where } : {},
+      limit
+    });
+    if (results.length === 0) {
+      if (!opts.json) {
+        process.stderr.write("No results found.\n");
+      }
+      return;
+    }
+    if (opts.json) {
+      for (const result of results) {
+        const output = {
+          ...result.data,
+          _score: result._score,
+          _engine: result._engine
+        };
+        process.stdout.write(JSON.stringify(output) + "\n");
+      }
+    } else {
+      for (const result of results) {
+        const score = typeof result._score === "number" ? ` (score: ${result._score.toFixed(4)})` : "";
+        const id = result.data.id ? `[${result.data.id}]` : "";
+        const dataKeys = Object.keys(result.data).filter((k) => k !== "id");
+        const preview = dataKeys.slice(0, 3).map((k) => {
+          const v = result.data[k];
+          const s = typeof v === "string" ? v : JSON.stringify(v);
+          const truncated = s != null && s.length > 60 ? s.substring(0, 57) + "..." : s;
+          return `${k}=${truncated}`;
+        }).join("  ");
+        const more = dataKeys.length > 3 ? `  (+${dataKeys.length - 3} more)` : "";
+        process.stdout.write(`${id}${score}  ${preview}${more}
+`);
+      }
+      process.stderr.write(`${results.length} result(s) found.
+`);
+    }
+  } finally {
+    if (lanceEngine) await lanceEngine.close();
+    if (sqliteEngine) sqliteEngine.close();
+  }
+}
+
+// src/commands/config.ts
+var ENGINE_DESC2 = {
+  hybrid: "LanceDB + SQLite",
+  relational: "SQLite",
+  vector: "LanceDB"
+};
+function maskApiKey(key) {
+  if (key.length <= 7) return "****";
+  return `${key.slice(0, 3)}...${key.slice(-4)}`;
+}
+async function executeConfig(opts, manager = new XdbConfigManager()) {
+  const cfg = await manager.load();
+  const registry = new PolicyRegistry();
+  const policies = registry.listPolicies();
+  if (opts.json) {
+    let hasApiKey = false;
+    const provider2 = cfg.defaultEmbedProvider;
+    if (provider2) {
+      try {
+        await manager.resolveApiKey(provider2);
+        hasApiKey = true;
+      } catch {
+        hasApiKey = false;
+      }
+    }
+    const providerConfig2 = cfg.providers.find((p) => p.name === provider2);
+    const output = {
+      embed: {
+        provider: cfg.defaultEmbedProvider ?? null,
+        model: cfg.defaultEmbedModel ?? null,
+        baseUrl: providerConfig2?.baseUrl ?? null,
+        hasApiKey
+      },
+      policies
+    };
+    process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+    return;
+  }
+  const provider = cfg.defaultEmbedProvider ?? "(not set)";
+  const model = cfg.defaultEmbedModel ?? "(not set)";
+  const providerConfig = cfg.providers.find((p) => p.name === cfg.defaultEmbedProvider);
+  const baseUrl = providerConfig?.baseUrl ?? "(default)";
+  let apiKeyDisplay = "(not set)";
+  if (cfg.defaultEmbedProvider) {
+    try {
+      const key = await manager.resolveApiKey(cfg.defaultEmbedProvider);
+      apiKeyDisplay = maskApiKey(key);
+    } catch {
+      apiKeyDisplay = "(not set)";
+    }
+  }
+  process.stdout.write("Embed Configuration:\n");
+  process.stdout.write(`  provider:  ${provider}
+`);
+  process.stdout.write(`  model:     ${model}
+`);
+  process.stdout.write(`  base-url:  ${baseUrl}
+`);
+  process.stdout.write(`  api-key:   ${apiKeyDisplay}
+`);
+  process.stdout.write("\n");
+  process.stdout.write("Available Policies:\n");
+  for (const p of policies) {
+    const name = `${p.main}/${p.minor}`;
+    const engines = ENGINE_DESC2[p.main] ?? p.main;
+    const fieldNames = Object.keys(p.fields);
+    const fieldsStr = fieldNames.length > 0 ? fieldNames.map((f) => {
+      const caps = p.fields[f].findCaps.join(", ");
+      return `${f} [${caps}]`;
+    }).join("; ") : "(none)";
+    const autoIdx = p.autoIndex ? "yes" : "no";
+    process.stdout.write(`  ${name}
+`);
+    process.stdout.write(`    engines:    ${engines}
+`);
+    process.stdout.write(`    fields:     ${fieldsStr}
+`);
+    process.stdout.write(`    autoIndex:  ${autoIdx}
+`);
+  }
+}
+async function executeConfigEmbed(opts, manager = new XdbConfigManager()) {
+  const cfg = await manager.load();
+  if (opts.setProvider !== void 0) {
+    cfg.defaultEmbedProvider = opts.setProvider;
+    await manager.save(cfg);
+    process.stdout.write(`Embed provider set to: ${opts.setProvider}
+`);
+  }
+  if (opts.setModel !== void 0) {
+    cfg.defaultEmbedModel = opts.setModel;
+    await manager.save(cfg);
+    process.stdout.write(`Embed model set to: ${opts.setModel}
+`);
+  }
+  if (opts.setKey !== void 0) {
+    if (!cfg.defaultEmbedProvider) {
+      throw new XDBError(
+        PARAMETER_ERROR,
+        "No embed provider configured. Run: xdb config embed --set-provider <name>"
+      );
+    }
+    const existing = cfg.providers.find((p) => p.name === cfg.defaultEmbedProvider);
+    if (existing) {
+      existing.apiKey = opts.setKey;
+    } else {
+      cfg.providers.push({ name: cfg.defaultEmbedProvider, apiKey: opts.setKey });
+    }
+    await manager.save(cfg);
+    process.stdout.write(`API key set for provider: ${cfg.defaultEmbedProvider}
+`);
+  }
+  if (opts.setBaseUrl !== void 0) {
+    if (!cfg.defaultEmbedProvider) {
+      throw new XDBError(
+        PARAMETER_ERROR,
+        "No embed provider configured. Run: xdb config embed --set-provider <name>"
+      );
+    }
+    const existing = cfg.providers.find((p) => p.name === cfg.defaultEmbedProvider);
+    if (existing) {
+      existing.baseUrl = opts.setBaseUrl;
+    } else {
+      cfg.providers.push({ name: cfg.defaultEmbedProvider, baseUrl: opts.setBaseUrl });
+    }
+    await manager.save(cfg);
+    process.stdout.write(`Base URL set for provider: ${cfg.defaultEmbedProvider}
+`);
+  }
+}
+function registerConfigCommands(config2) {
+  config2.option("--json", "Output as JSON").action(async (opts) => {
+    try {
+      await executeConfig(opts);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  config2.command("embed").description("Manage embed service configuration").option("--set-provider <name>", "Set the default embed provider").option("--set-model <model>", "Set the default embed model").option("--set-key <apiKey>", "Set the API key for the current provider").option("--set-base-url <url>", "Set the base URL for the current provider").action(async (opts) => {
+    try {
+      await executeConfigEmbed(opts);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/embed.ts
+import { readFile as readFile3 } from "fs/promises";
+
+// src/embed-io.ts
+function vectorToHex(vec) {
+  const buf = new ArrayBuffer(4);
+  const view = new DataView(buf);
+  const result = new Array(vec.length);
+  for (let i = 0; i < vec.length; i++) {
+    view.setFloat32(0, vec[i], false);
+    let hex = "";
+    for (let b = 0; b < 4; b++) {
+      const byte = view.getUint8(b);
+      hex += (byte < 16 ? "0" : "") + byte.toString(16);
+    }
+    result[i] = hex;
+  }
+  return result;
+}
+function parseBatchInput(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new XDBError(
+      PARAMETER_ERROR,
+      "Invalid batch input: not valid JSON"
+    );
+  }
+  if (!Array.isArray(parsed)) {
+    throw new XDBError(
+      PARAMETER_ERROR,
+      "Invalid batch input: expected a JSON array of strings"
+    );
+  }
+  for (let i = 0; i < parsed.length; i++) {
+    if (typeof parsed[i] !== "string") {
+      throw new XDBError(
+        PARAMETER_ERROR,
+        `Invalid batch input: element at index ${i} is not a string`
+      );
+    }
+  }
+  return parsed;
+}
+function formatEmbeddingOutput(result, options) {
+  if (!options.json) {
+    return result.embeddings.map((emb) => JSON.stringify(vectorToHex(emb))).join("\n");
+  }
+  const usage = {
+    prompt_tokens: result.usage.promptTokens,
+    total_tokens: result.usage.totalTokens
+  };
+  if (options.batch) {
+    return JSON.stringify({
+      embeddings: result.embeddings.map((emb) => vectorToHex(emb)),
+      model: result.model,
+      usage
+    });
+  }
+  return JSON.stringify({
+    embedding: vectorToHex(result.embeddings[0]),
+    model: result.model,
+    usage
+  });
+}
+
+// src/embedding-models.ts
+var EMBEDDING_MODEL_LIMITS = {
+  // OpenAI
+  "text-embedding-3-small": 8191,
+  "text-embedding-3-large": 8191,
+  "text-embedding-ada-002": 8191,
+  // Google
+  "text-embedding-004": 2048,
+  // Cohere
+  "embed-english-v3.0": 512,
+  "embed-multilingual-v3.0": 512,
+  "embed-english-light-v3.0": 512,
+  "embed-multilingual-light-v3.0": 512
+};
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function truncateText(text, model) {
+  const limit = EMBEDDING_MODEL_LIMITS[model];
+  const originalTokens = estimateTokens(text);
+  if (limit === void 0) {
+    return { text, truncated: false, originalTokens };
+  }
+  if (originalTokens <= limit) {
+    return { text, truncated: false, originalTokens };
+  }
+  const maxChars = limit * CHARS_PER_TOKEN;
+  return {
+    text: text.slice(0, maxChars),
+    truncated: true,
+    originalTokens
+  };
+}
+
+// src/commands/embed.ts
+async function readStdin3() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve(data);
+    });
+    process.stdin.on("error", (err) => {
+      reject(new XDBError(RUNTIME_ERROR, `Failed to read from stdin: ${err.message}`));
+    });
+  });
+}
+async function executeEmbed(text, opts, manager = new XdbConfigManager(), clientFactory) {
+  const { provider, model, providerConfig, apiKey } = await manager.resolveEmbedConfig();
+  const hasExplicitInput = text !== void 0 || opts.inputFile !== void 0;
+  const stdinAvailable = !process.stdin.isTTY && !hasExplicitInput;
+  const sourceCount = [
+    text !== void 0,
+    stdinAvailable,
+    opts.inputFile !== void 0
+  ].filter(Boolean).length;
+  if (sourceCount > 1) {
+    throw new XDBError(
+      PARAMETER_ERROR,
+      "Multiple input sources specified. Provide input via argument, stdin, or --input-file (only one)."
+    );
+  }
+  let rawInput;
+  if (text !== void 0) {
+    rawInput = text;
+  } else if (opts.inputFile) {
+    try {
+      rawInput = await readFile3(opts.inputFile, "utf-8");
+    } catch (err) {
+      throw new XDBError(
+        RUNTIME_ERROR,
+        `Failed to read input file: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  } else if (stdinAvailable) {
+    rawInput = await readStdin3();
+  } else {
+    throw new XDBError(
+      PARAMETER_ERROR,
+      "No input text provided. Provide input via argument, stdin, or --input-file."
+    );
+  }
+  let texts;
+  if (opts.batch) {
+    texts = parseBatchInput(rawInput);
+  } else {
+    texts = [rawInput];
+  }
+  texts = texts.map((t) => {
+    const result = truncateText(t, model);
+    if (result.truncated) {
+      const truncatedTokens = Math.ceil(result.text.length / 4);
+      const modelLimit = EMBEDDING_MODEL_LIMITS[model] ?? truncatedTokens;
+      if (opts.json) {
+        const warning = {
+          type: "warning",
+          data: {
+            message: `Input text truncated from ~${result.originalTokens} tokens to ${truncatedTokens} tokens (model limit: ${modelLimit})`,
+            originalTokens: result.originalTokens,
+            truncatedTokens
+          }
+        };
+        process.stderr.write(JSON.stringify(warning) + "\n");
+      } else {
+        process.stderr.write(
+          `[Warning] Input text truncated from ~${result.originalTokens} tokens to ${truncatedTokens} tokens (model limit: ${modelLimit})
+`
+        );
+      }
+    }
+    return result.text;
+  });
+  const clientConfig = { provider, apiKey, model };
+  if (providerConfig.baseUrl) {
+    clientConfig.baseUrl = providerConfig.baseUrl;
+  }
+  if (providerConfig.api) {
+    clientConfig.api = providerConfig.api;
+  }
+  const client = clientFactory ? clientFactory(clientConfig) : new EmbeddingClient(clientConfig);
+  const response = await client.embed({ texts, model });
+  const output = formatEmbeddingOutput(response, {
+    json: opts.json ?? false,
+    batch: opts.batch ?? false
+  });
+  process.stdout.write(output + "\n");
+}
+function registerEmbedCommand(program2) {
+  program2.command("embed [text]").description("Embed text using the configured embedding provider").option("--batch", "Parse input as a JSON string array for batch embedding").option("--json", "Output as JSON").option("--input-file <path>", "Read input from a file").action(async (text, opts) => {
+    try {
+      await executeEmbed(text, opts);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/help.ts
+var MAIN_EXAMPLES = `
+Examples:
+  $ xdb col init my-docs --policy hybrid/knowledge-base
+  $ xdb put my-docs '{"content":"How to use tar"}'
+  $ xdb find my-docs "compress files" --similar
+  $ xdb col list
+  $ xdb col info my-docs
+  $ xdb policy list
+
+Prerequisites:
+  \u5411\u91CF\u5316\u529F\u80FD\u4F9D\u8D56 pai \u547D\u4EE4\u3002\u8BF7\u786E\u4FDD pai \u5DF2\u5B89\u88C5\u5E76\u914D\u7F6E\u4E86 embedding provider:
+    pai model default --embed-provider openai --embed-model text-embedding-3-small
+
+Data:
+  \u6570\u636E\u76EE\u5F55: ~/.local/share/xdb/`;
+var MAIN_VERBOSE = `
+Policies:
+  hybrid/knowledge-base    \u5411\u91CF + \u5168\u6587\u68C0\u7D22\uFF08\u6700\u5E38\u7528\uFF09
+  relational/structured-logs  \u7ED3\u6784\u5316\u65E5\u5FD7
+  relational/simple-kv     \u7B80\u5355\u952E\u503C\u5BF9
+  vector/feature-store     \u7279\u5F81\u5B58\u50A8
+
+Storage:
+  ~/.local/share/xdb/collections/<name>/
+    collection_meta.json   Policy \u5FEB\u7167 + \u5143\u6570\u636E
+    vector.lance/          LanceDB \u5411\u91CF\u6570\u636E
+    relational.db          SQLite \u5173\u7CFB\u6570\u636E + FTS
+
+Exit Codes:
+  0  \u6210\u529F
+  2  \u53C2\u6570\u9519\u8BEF / \u96C6\u5408\u4E0D\u5B58\u5728 / \u80FD\u529B\u4E0D\u5339\u914D
+  1  \u8FD0\u884C\u65F6\u9519\u8BEF\uFF08\u5F15\u64CE\u6545\u969C\u3001pai \u8C03\u7528\u5931\u8D25\u7B49\uFF09`;
+var COL_INIT_EXAMPLES = `
+Examples:
+  $ xdb col init my-docs --policy hybrid/knowledge-base
+  $ xdb col init logs --policy relational
+  $ xdb col init my-col --policy hybrid --params '{"fields":{"title":{"findCaps":["match"]}}}'`;
+var COL_LIST_EXAMPLES = `
+Examples:
+  $ xdb col list
+  $ xdb col list --json                               # JSON array \u8F93\u51FA`;
+var COL_RM_EXAMPLES = `
+Examples:
+  $ xdb col rm my-docs
+
+Warning: \u6B64\u64CD\u4F5C\u4E0D\u53EF\u9006\uFF0C\u5C06\u7269\u7406\u5220\u9664\u96C6\u5408\u76EE\u5F55\u53CA\u6240\u6709\u7D22\u5F15\u6587\u4EF6\u3002`;
+var COL_INFO_EXAMPLES = `
+Examples:
+  $ xdb col info my-docs                              # \u4EBA\u7C7B\u53EF\u8BFB
+  $ xdb col info my-docs --json                       # JSON \u8F93\u51FA`;
+var POLICY_LIST_EXAMPLES = `
+Examples:
+  $ xdb policy list                                    # \u4EBA\u7C7B\u53EF\u8BFB
+  $ xdb policy list --json                             # JSON \u8F93\u51FA`;
+var PUT_EXAMPLES = `
+Examples:
+  $ xdb put my-docs '{"content":"How to use tar"}'    # \u4F4D\u7F6E\u53C2\u6570
+  $ echo '{"content":"Git branching"}' | xdb put my-docs  # stdin \u8F93\u5165
+  $ cat data.jsonl | xdb put my-docs --batch           # \u6279\u91CF\u5199\u5165
+
+Stdin:
+  \u652F\u6301\u901A\u8FC7\u7BA1\u9053\u4F20\u5165 JSON \u6216 JSONL \u6570\u636E\u3002
+
+Note:
+  \u76F8\u540C id \u7684\u8BB0\u5F55\u6267\u884C upsert\uFF08\u5E42\u7B49\u64CD\u4F5C\uFF09\u3002
+  --batch --json \u8F93\u51FA: {"inserted":N,"updated":N,"errors":N}`;
+var FIND_EXAMPLES = `
+Examples:
+  $ xdb find my-docs "compress files" --similar        # \u8BED\u4E49\u641C\u7D22
+  $ xdb find my-docs "tar compression" --match         # \u5168\u6587\u68C0\u7D22
+  $ xdb find my-docs --where "json_extract(data, '$.category') = 'network'"
+  $ echo "database optimization" | xdb find my-docs --similar  # stdin \u67E5\u8BE2
+
+Stdin:
+  \u652F\u6301\u901A\u8FC7\u7BA1\u9053\u4F20\u5165\u67E5\u8BE2\u6587\u672C\uFF08\u7528\u4E8E --similar \u548C --match\uFF09\u3002
+
+JSON output (--json):
+  JSONL \u683C\u5F0F\uFF0C\u6BCF\u884C\u4E00\u4E2A\u7ED3\u679C\uFF0C\u542B _score \u548C _engine \u5143\u6570\u636E\u3002`;
+function installHelp(program2) {
+  program2.addHelpText("after", MAIN_EXAMPLES);
+  installVerboseHelp(program2);
+}
+function addColExamples(col2) {
+  for (const sub of col2.commands) {
+    const name = sub.name();
+    if (name === "init") sub.addHelpText("after", COL_INIT_EXAMPLES);
+    else if (name === "list") sub.addHelpText("after", COL_LIST_EXAMPLES);
+    else if (name === "rm") sub.addHelpText("after", COL_RM_EXAMPLES);
+    else if (name === "info") sub.addHelpText("after", COL_INFO_EXAMPLES);
+  }
+}
+function addPolicyExamples(policy2) {
+  for (const sub of policy2.commands) {
+    const name = sub.name();
+    if (name === "list") sub.addHelpText("after", POLICY_LIST_EXAMPLES);
+  }
+}
+function addPutExamples(cmd) {
+  cmd.addHelpText("after", PUT_EXAMPLES);
+}
+function addFindExamples(cmd) {
+  cmd.addHelpText("after", FIND_EXAMPLES);
+}
+function installVerboseHelp(program2) {
+  program2.option("--verbose", "(\u4E0E --help \u4E00\u8D77\u4F7F\u7528) \u663E\u793A\u5B8C\u6574\u5E2E\u52A9\u4FE1\u606F");
+  program2.on("option:verbose", () => {
+    program2.__verboseHelp = true;
+  });
+  program2.addHelpText("afterAll", () => {
+    if (program2.__verboseHelp) {
+      return MAIN_VERBOSE;
+    }
+    return "";
+  });
+}
+
+// src/cli.ts
+process.stdout.on("error", (err) => {
+  if (err.code === "EPIPE") process.exit(0);
+  throw err;
+});
+process.stderr.on("error", (err) => {
+  if (err.code === "EPIPE") process.exit(0);
+  throw err;
+});
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var { version: pkgVersion } = JSON.parse(readFileSync(join8(__dirname, "../package.json"), "utf8"));
+var program = new Command();
+program.name("xdb").description("Intent-driven data hub CLI for AI agents").version(`xdb ${pkgVersion}`).showHelpAfterError(true);
+program.exitOverride();
+installHelp(program);
+var col = program.command("col").description("Manage collections");
+registerColCommands(col);
+addColExamples(col);
+var policy = program.command("policy").description("Discover available policies");
+registerPolicyCommands(policy);
+addPolicyExamples(policy);
+policy.action(() => {
+  policy.outputHelp();
+});
+registerPutCommand(program);
+addPutExamples(program.commands.find((c) => c.name() === "put"));
+registerFindCommand(program);
+addFindExamples(program.commands.find((c) => c.name() === "find"));
+var config = program.command("config").description("Manage xdb configuration");
+registerConfigCommands(config);
+registerEmbedCommand(program);
+program.configureOutput({
+  writeErr: (str) => process.stderr.write(str),
+  writeOut: (str) => process.stdout.write(str)
+});
+col.action(() => {
+  col.outputHelp();
+});
+(async () => {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err && typeof err === "object" && "exitCode" in err) {
+      const exitCode = err.exitCode;
+      process.exitCode = exitCode === 1 ? 2 : exitCode;
+    } else {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 1;
+    }
+  }
+})();
+//# sourceMappingURL=cli.js.map