@withone/cli 1.42.0 → 1.43.3

package/README.md

@@ -303,24 +303,61 @@ Default TTL is 1 hour. Configure via `ONE_CACHE_TTL` environment variable or `ca
 
 Note: `actions execute` is never cached — it always hits the API fresh.
 
-### `one sync`
+### `one mem` — unified memory store
 
-Sync platform data into local SQLite for instant queries, full-text search, scheduled refresh, and change-driven automation. The sync engine (`better-sqlite3`) is an optional dependency — install it once per machine:
+One ships a local memory store (a real Postgres process bootstrapped on demand via the bundled `embedded-postgres` plugin, with a `postgres` plugin for remote/self-hosted) that backs both user-authored notes and synced platform data. **Zero-config** — the first `one mem` call on a fresh machine auto-initializes the cluster at `~/.one/pg/cluster/` and writes a daemon PID file so subsequent CLI invocations reuse it.
 
 ```bash
-one sync install && one sync doctor
+# User memories — works immediately on a new install
+one mem add note '{"content":"Design review is Thursday"}' --tags work --weight 7
+one mem search "design review"                       # hybrid FTS + semantic (if key set)
+one mem list note --limit 20
+
+# Listing synced platform rows — type is positional and namespaced as <platform>/<model>;
+# there is NO --platform flag and NO platform column in the schema.
+one mem list "gmail/threads"
+one mem list "attio/attioPeople" --limit 5
+
+# Enable semantic search (optional)
+one init                                             # re-run — prompts for OpenAI key
+# OR
+one mem config set embedding.apiKey sk-...           # writes top-level openaiApiKey
+# OR
+export OPENAI_API_KEY=sk-...                         # no persistence
+
+# Status + diagnostics
+one mem status                                       # backend, provider, _upgrade hint
+one mem doctor                                       # 7-check health report
 ```
 
+Key surfaces: `add`, `get`, `update`, `archive`, `list`, `search` (`--deep` forces semantic), `context`, `link`/`linked`/`unlink`, `sources`, `find-by-source`, `export`, `import`, `migrate`, `vacuum`, `reindex`. Run `one guide memory` for the full reference.
+
+### `one sync` (and `one mem sync` alias)
+
+Sync platform data into the unified memory store for instant queries, hybrid FTS + semantic search, scheduled refresh, and change-driven automation. Memory is always written; pass `--no-memory` to skip (rare).
+
 ```bash
-# Discover → init (one command: infer + late-bound connection + auto-test) → run
+# Discover → init (seeds from built-in, auto-tests) → declare searchable → preview → run
 one sync models stripe
-one sync init stripe balanceTransactions    # connection: { platform } baked in, test auto-run
+one sync init stripe balanceTransactions
+
+# Optional: declare clean fields for embedding, then preview
+one sync init stripe balanceTransactions --config '{
+  "memory": {
+    "embed": true,
+    "searchable": ["description","type","amount","currency"]
+  }
+}'
+one sync test stripe/balanceTransactions --show-searchable
+
+# Run — every row lands in memory (SQLite also written for enrich-phase compat)
 one sync run stripe --since 90d
+one mem sync run stripe                              # identical (alias)
 
-# Query, search, SQL
+# Query + search (reads from memory)
 one sync query stripe/balanceTransactions --where "status=available" --limit 20
-one sync search "refund"
-one sync sql stripe "SELECT count(*) FROM balanceTransactions"
+one sync query stripe/customers --where 'address.city=SF'   # dotted paths supported
+one sync search "refund"                             # hybrid, per-type
 
 # Schedule unattended syncs + change hooks
 one sync schedule add stripe --every 1h
@@ -334,20 +371,23 @@ one sync run stripe --full-refresh
 
 > **Connections are late-bound.** Profiles use `"connection": { "platform": "<name>", "tag"?: "..." }` instead of literal `connectionKey` strings. The key is resolved at sync time, so `one add <platform>` (re-auth) doesn't break the profile. `tag` only needed for multi-account platforms (e.g. two Gmail accounts).
 
+> **`memory.searchable` paths.** Drives what gets embedded + FTS-indexed. Supports numeric indexes (`values.name[0].full_name`) and `[]` wildcards (`messages[].snippet`, `messages[].payload.parts[].body.data`). Without declared paths the default walker concatenates every string — correct but noisy for hierarchical APIs. Always declare when `embed: true`.
+
 | Subcommand | What it does |
 |------------|-------------|
-| `install` / `doctor` | Install + verify the SQLite engine |
+| `profiles [platform]` | List built-in pre-validated profiles |
+| `doctor` | Verify sync engine health |
 | `models <platform>` | Discover available data models |
-| `init <platform> <model>` | Create profile (auto-infers all fields, auto-resolves key, auto-runs test) |
-| `test <platform>/<model>` | Validate + auto-fix profile from real API response (also runs inside init) |
-| `run <platform>` | Sync data (`--full-refresh`, `--since`, `--dry-run`) |
-| `query <platform>/<model>` | Query with `--where`, `--after/before`, `--refresh` |
-| `search <query>` | FTS5 across all synced data |
-| `sql <platform> <sql>` | Raw SELECT queries |
+| `init <platform> <model>` | Create/patch profile (seeds from built-in, auto-tests) |
+| `test <platform>/<model>` | Validate profile. `--show-searchable` previews embedded text |
+| `run <platform>` | Sync data (`--full-refresh`, `--since`, `--dry-run`, `--no-memory`) |
+| `query <platform>/<model>` | Query memory with `--where` (dotted paths), `--after/before` |
+| `search <query>` | Hybrid FTS + semantic across all synced data |
+| `list [platform]` | Show profiles, record counts, freshness |
 | `schedule add/list/status/remove/repair` | Cron-backed scheduled syncs with drift detection |
-| `remove <platform>` | Delete local data (`--dry-run` to preview) |
+| `remove <platform>` | Delete synced data (`--dry-run` to preview) |
 
-Change hooks (`onInsert`, `onUpdate`, `onChange`) fire per-page during sync — pipe to a shell command, a flow, or an event log. Root-array responses (e.g. Hacker News `/v0/topstories.json` → `[9129911, 9129199, ...]`) are supported by setting `resultsPath` to `""`, `"$"`, or `"."`; primitive elements are auto-wrapped as `{ [idField]: value }`. Run `one guide sync` for the full reference.
+Change hooks (`onInsert`, `onUpdate`, `onChange`) fire per-page during sync — pipe to a shell command, a flow, or an event log. Root-array responses (e.g. Hacker News `/v0/topstories.json` → `[9129911, 9129199, ...]`) are supported by setting `resultsPath` to `""`, `"$"`, or `"."`; primitive elements are auto-wrapped as `{ [idField]: value }`. Run `one guide sync` or `one guide memory` for the full reference.
 
 ### `one relay`
 

package/dist/chunk-3ZJVO4GP.js

@@ -0,0 +1,59 @@
+import {
+  error,
+  isAgentMode,
+  json,
+  requireMemoryInit
+} from "./chunk-MRGKKO54.js";
+import {
+  getBackend
+} from "./chunk-IAFQVFCB.js";
+
+// src/commands/mem/sql.ts
+async function memSqlCommand(sql) {
+  requireMemoryInit();
+  const backend = await getBackend();
+  if (!backend.capabilities().rawSql || !backend.raw) {
+    error(
+      "This memory backend does not support raw SQL (capabilities.rawSql = false). Use `mem list` / `mem search` / `mem find-by-source` for high-level queries."
+    );
+  }
+  try {
+    const result = await backend.raw(sql);
+    if (isAgentMode()) {
+      json({
+        columns: result.columns,
+        rows: result.rows,
+        rowCount: result.rowCount
+      });
+      return;
+    }
+    if (result.rows.length === 0) {
+      console.log("(0 rows)");
+      return;
+    }
+    console.log(JSON.stringify(result.rows, null, 2));
+    console.log(`
+${result.rowCount} row(s)`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+  }
+}
+async function syncSqlCommand(platformModel, sql) {
+  const [platform, model] = platformModel.split("/");
+  if (!platform || !model) {
+    error(`Usage: one sync sql <platform>/<model> "<SELECT ...>". Example: one sync sql attio/attioPeople "SELECT data->>'id' FROM mem_records WHERE type = 'attio/attioPeople'"`);
+  }
+  const type = `${platform}/${model}`;
+  if (!isAgentMode() && !sql.includes(`'${type}'`) && !sql.includes(`"${type}"`)) {
+    process.stderr.write(
+      `  note: this query does not filter to type = '${type}'. Results span all types. Add \`WHERE type = '${type}'\` to scope.
+`
+    );
+  }
+  await memSqlCommand(sql);
+}
+
+export {
+  memSqlCommand,
+  syncSqlCommand
+};

package/dist/chunk-44CV5IMX.js

@@ -0,0 +1,38 @@
+// src/lib/dot-path.ts
+function getByDotPath(obj, dotPath) {
+  const parts = dotPath.split(".").flatMap((part) => {
+    const bracketMatch = part.match(/^([^[]+)\[(\d+)\]$/);
+    if (bracketMatch) {
+      return [bracketMatch[1], bracketMatch[2]];
+    }
+    return [part];
+  });
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (Array.isArray(current) && /^\d+$/.test(part)) {
+      current = current[parseInt(part, 10)];
+    } else if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function setByDotPath(obj, dotPath, value) {
+  const parts = dotPath.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current[parts[i]] === void 0 || current[parts[i]] === null) {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
+export {
+  getByDotPath,
+  setByDotPath
+};

package/dist/chunk-AU2ZEEMS.js

@@ -0,0 +1,477 @@
+// src/lib/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function configDir() {
+  return path.join(os.homedir(), ".one");
+}
+function configFile() {
+  return path.join(configDir(), "config.json");
+}
+function projectsDir() {
+  return path.join(configDir(), "projects");
+}
+function getProjectRoot(cwd = process.cwd()) {
+  let dir = path.resolve(cwd);
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    if (fs.existsSync(path.join(dir, ".git")) || fs.existsSync(path.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return path.resolve(cwd);
+}
+function getProjectSlug(projectRoot = getProjectRoot()) {
+  return projectRoot.replace(/[\\/]/g, "-");
+}
+function getProjectConfigDir(projectRoot = getProjectRoot()) {
+  return path.join(projectsDir(), getProjectSlug(projectRoot));
+}
+function getProjectConfigPath(projectRoot = getProjectRoot()) {
+  return path.join(getProjectConfigDir(projectRoot), "config.json");
+}
+function getGlobalConfigPath() {
+  return configFile();
+}
+function resolveConfig() {
+  const projectRoot = getProjectRoot();
+  const projectSlug = getProjectSlug(projectRoot);
+  const projectPath = getProjectConfigPath(projectRoot);
+  if (fs.existsSync(projectPath)) {
+    const config = readConfigFile(projectPath);
+    if (config) {
+      return { config, scope: "project", path: projectPath, projectRoot, projectSlug };
+    }
+  }
+  const root = path.parse(process.cwd()).root;
+  let dir = path.resolve(process.cwd());
+  while (dir !== root) {
+    dir = path.dirname(dir);
+    const slug = getProjectSlug(dir);
+    const configPath = path.join(projectsDir(), slug, "config.json");
+    if (fs.existsSync(configPath)) {
+      const config = readConfigFile(configPath);
+      if (config) {
+        return { config, scope: "project", path: configPath, projectRoot: dir, projectSlug: slug };
+      }
+    }
+  }
+  if (fs.existsSync(configFile())) {
+    const config = readConfigFile(configFile());
+    if (config) {
+      return { config, scope: "global", path: configFile(), projectRoot, projectSlug };
+    }
+  }
+  return { config: null, scope: null, path: configFile(), projectRoot, projectSlug };
+}
+function readConfigFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function configExists() {
+  return resolveConfig().config !== null;
+}
+function globalConfigExists() {
+  return fs.existsSync(configFile());
+}
+function projectConfigExists(projectRoot = getProjectRoot()) {
+  return fs.existsSync(getProjectConfigPath(projectRoot));
+}
+function readConfig() {
+  return resolveConfig().config;
+}
+function readGlobalConfig() {
+  if (!fs.existsSync(configFile())) return null;
+  return readConfigFile(configFile());
+}
+function readProjectConfig() {
+  const projectPath = getProjectConfigPath();
+  if (!fs.existsSync(projectPath)) return null;
+  return readConfigFile(projectPath);
+}
+function writeConfig(config, scope) {
+  const targetScope = scope ?? resolveConfig().scope ?? "global";
+  if (targetScope === "project") {
+    const dir = getProjectConfigDir();
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+    const filePath = getProjectConfigPath();
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2), { mode: 384 });
+    return;
+  }
+  if (!fs.existsSync(configDir())) {
+    fs.mkdirSync(configDir(), { mode: 448 });
+  }
+  fs.writeFileSync(configFile(), JSON.stringify(config, null, 2), { mode: 384 });
+}
+function readOneRc() {
+  const rcPath = path.join(process.cwd(), ".onerc");
+  if (!fs.existsSync(rcPath)) return {};
+  try {
+    const content = fs.readFileSync(rcPath, "utf-8");
+    const result = {};
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex === -1) continue;
+      const key = trimmed.slice(0, eqIndex).trim();
+      const value = trimmed.slice(eqIndex + 1).trim();
+      result[key] = value;
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function getApiKey() {
+  if (process.env.ONE_SECRET) return process.env.ONE_SECRET;
+  const rc = readOneRc();
+  if (rc.ONE_SECRET) return rc.ONE_SECRET;
+  return readConfig()?.apiKey ?? null;
+}
+function getOpenAiApiKey() {
+  if (process.env.OPENAI_API_KEY) return process.env.OPENAI_API_KEY;
+  const rc = readOneRc();
+  if (rc.OPENAI_API_KEY) return rc.OPENAI_API_KEY;
+  return readConfig()?.openaiApiKey ?? null;
+}
+function setOpenAiApiKey(key) {
+  const resolved = resolveConfig();
+  if (!resolved.config) {
+    throw new Error("No One config found. Run `one init` first.");
+  }
+  if (key === "") {
+    delete resolved.config.openaiApiKey;
+  } else {
+    resolved.config.openaiApiKey = key;
+  }
+  writeConfig(resolved.config, resolved.scope ?? "global");
+}
+function getAccessControlFromAllSources() {
+  const rc = readOneRc();
+  const fileAc = getAccessControl();
+  const merged = { ...fileAc };
+  if (rc.ONE_PERMISSIONS) {
+    merged.permissions = rc.ONE_PERMISSIONS;
+  }
+  if (rc.ONE_CONNECTION_KEYS) {
+    merged.connectionKeys = rc.ONE_CONNECTION_KEYS.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  if (rc.ONE_ACTION_IDS) {
+    merged.actionIds = rc.ONE_ACTION_IDS.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  if (rc.ONE_KNOWLEDGE_AGENT) {
+    merged.knowledgeAgent = rc.ONE_KNOWLEDGE_AGENT === "true";
+  }
+  return merged;
+}
+function getAccessControl() {
+  return readConfig()?.accessControl ?? {};
+}
+var DEFAULT_API_BASE = "https://api.withone.ai/v1";
+function getApiBase() {
+  const config = readConfig();
+  if (config?.apiBase) return `${config.apiBase}/v1`;
+  return DEFAULT_API_BASE;
+}
+function updateApiBase(url) {
+  const config = readConfig();
+  if (!config) return;
+  if (url) {
+    config.apiBase = url;
+  } else {
+    delete config.apiBase;
+  }
+  delete config.whoami;
+  writeConfig(config);
+}
+function getCacheTtl() {
+  if (process.env.ONE_CACHE_TTL) {
+    const val = parseInt(process.env.ONE_CACHE_TTL, 10);
+    if (!isNaN(val) && val > 0) return val;
+  }
+  const config = readConfig();
+  if (config?.cacheTtl && config.cacheTtl > 0) return config.cacheTtl;
+  return 3600;
+}
+function updateAccessControl(settings) {
+  const config = readConfig();
+  if (!config) return;
+  const cleaned = {};
+  if (settings.permissions && settings.permissions !== "admin") {
+    cleaned.permissions = settings.permissions;
+  }
+  if (settings.connectionKeys && !(settings.connectionKeys.length === 1 && settings.connectionKeys[0] === "*")) {
+    cleaned.connectionKeys = settings.connectionKeys;
+  }
+  if (settings.actionIds && !(settings.actionIds.length === 1 && settings.actionIds[0] === "*")) {
+    cleaned.actionIds = settings.actionIds;
+  }
+  if (settings.knowledgeAgent) {
+    cleaned.knowledgeAgent = true;
+  }
+  if (Object.keys(cleaned).length === 0) {
+    delete config.accessControl;
+  } else {
+    config.accessControl = cleaned;
+  }
+  writeConfig(config);
+}
+function getWhoAmI() {
+  return readConfig()?.whoami ?? null;
+}
+function updateWhoAmI(whoami) {
+  const config = readConfig();
+  if (!config) return;
+  config.whoami = whoami;
+  writeConfig(config);
+}
+async function ensureWhoAmI(api) {
+  const cached = getWhoAmI();
+  if (cached) return cached;
+  try {
+    const whoami = await api.whoami();
+    updateWhoAmI(whoami);
+    return whoami;
+  } catch {
+    return null;
+  }
+}
+function getEnvFromApiKey(apiKey) {
+  return apiKey.startsWith("sk_test_") ? "test" : "live";
+}
+
+// src/lib/memory/config.ts
+var DEFAULT_MEMORY_CONFIG = {
+  backend: "embedded-postgres",
+  plugins: [],
+  embedding: {
+    provider: "none",
+    model: "text-embedding-3-small",
+    dimensions: 1536
+  },
+  defaults: {
+    trackAccessOnSearch: true,
+    embedOnAdd: true,
+    embedOnSync: false
+  }
+};
+function getMemoryConfig() {
+  const config = readConfig();
+  return config?.memory ?? null;
+}
+function getMemoryConfigOrDefault() {
+  return getMemoryConfig() ?? DEFAULT_MEMORY_CONFIG;
+}
+function memoryConfigExists() {
+  return getMemoryConfig() !== null;
+}
+function updateMemoryConfig(patch, opts = {}) {
+  const config = readConfig();
+  if (!config) {
+    throw new Error("No One config found. Run `one init` first.");
+  }
+  const current = config.memory ?? DEFAULT_MEMORY_CONFIG;
+  const next = opts.replace ? patch : { ...current, ...patch };
+  config.memory = next;
+  writeConfig(config);
+  return next;
+}
+function getEmbeddingApiKey() {
+  const fromCore = getOpenAiApiKey();
+  if (fromCore) return fromCore;
+  const mem = getMemoryConfig();
+  return mem?.embedding.apiKey ?? null;
+}
+function setOpenAiApiKey2(key) {
+  setOpenAiApiKey(key);
+  if (key === "") return;
+  const mem = getMemoryConfig();
+  if (!mem) return;
+  if (mem.embedding.provider === "openai") return;
+  updateMemoryConfig({
+    ...mem,
+    embedding: { ...mem.embedding, provider: "openai" }
+  });
+}
+
+// src/lib/memory/embedding.ts
+var FETCH_TIMEOUT_MS = 3e4;
+function fetchWithTimeout(url, init, timeoutMs) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  return fetch(url, { ...init, signal: ctrl.signal }).finally(() => clearTimeout(t));
+}
+async function embed(text, opts = {}) {
+  const clean = text?.trim();
+  if (!clean) return null;
+  const cfg = getMemoryConfigOrDefault();
+  if (cfg.embedding.provider !== "openai") return null;
+  const apiKey = getEmbeddingApiKey();
+  if (!apiKey) return null;
+  const model = opts.model ?? cfg.embedding.model;
+  const dimensions = cfg.embedding.dimensions;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const res = await fetchWithTimeout("https://api.openai.com/v1/embeddings", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          input: clean.slice(0, 8e3),
+          dimensions
+        })
+      }, FETCH_TIMEOUT_MS);
+      if (!res.ok) {
+        if (res.status === 429 || res.status >= 500) {
+          await sleep(500 * (attempt + 1));
+          continue;
+        }
+        const body2 = await res.text();
+        throw new Error(`OpenAI embeddings ${res.status}: ${body2}`);
+      }
+      const body = await res.json();
+      const vector = body.data[0]?.embedding;
+      if (!vector || vector.length !== dimensions) {
+        throw new Error(`Unexpected embedding shape (got length ${vector?.length})`);
+      }
+      return { vector, model: `openai:${model}` };
+    } catch (err) {
+      if (attempt === 2) {
+        process.stderr.write(`[mem] embedding failed: ${err instanceof Error ? err.message : String(err)}
+`);
+        return null;
+      }
+      await sleep(500 * (attempt + 1));
+    }
+  }
+  return null;
+}
+async function embedBatch(texts, opts = {}) {
+  if (texts.length === 0) return [];
+  const cfg = getMemoryConfigOrDefault();
+  if (cfg.embedding.provider !== "openai") return texts.map(() => null);
+  const apiKey = getEmbeddingApiKey();
+  if (!apiKey) return texts.map(() => null);
+  const model = opts.model ?? cfg.embedding.model;
+  const dimensions = cfg.embedding.dimensions;
+  const active = [];
+  texts.forEach((t, i) => {
+    const clean = t?.trim();
+    if (clean) active.push({ index: i, input: clean.slice(0, 8e3) });
+  });
+  if (active.length === 0) return texts.map(() => null);
+  const result = texts.map(() => null);
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const res = await fetchWithTimeout("https://api.openai.com/v1/embeddings", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          input: active.map((a) => a.input),
+          dimensions
+        })
+      }, FETCH_TIMEOUT_MS);
+      if (!res.ok) {
+        if (res.status === 429 || res.status >= 500) {
+          await sleep(500 * (attempt + 1));
+          continue;
+        }
+        const body2 = await res.text();
+        throw new Error(`OpenAI embeddings ${res.status}: ${body2}`);
+      }
+      const body = await res.json();
+      for (const item of body.data) {
+        const slot = active[item.index];
+        if (!slot) continue;
+        result[slot.index] = { vector: item.embedding, model: `openai:${model}` };
+      }
+      return result;
+    } catch (err) {
+      if (attempt === 2) {
+        process.stderr.write(`[mem] batch embedding failed: ${err instanceof Error ? err.message : String(err)}
+`);
+        return result;
+      }
+      await sleep(500 * (attempt + 1));
+    }
+  }
+  return result;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function defaultSearchableText(data, maxLen = 4e3) {
+  const parts = [];
+  const walk = (value, depth = 0) => {
+    if (value === null || value === void 0) return;
+    if (typeof value === "string" && value.trim()) {
+      parts.push(value.trim());
+      return;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      parts.push(String(value));
+      return;
+    }
+    if (depth > 4) return;
+    if (Array.isArray(value)) {
+      for (const v of value) walk(v, depth + 1);
+      return;
+    }
+    if (typeof value === "object") {
+      for (const v of Object.values(value)) walk(v, depth + 1);
+    }
+  };
+  walk(data);
+  const joined = parts.join(" ").replace(/\s+/g, " ").trim();
+  return joined.length > maxLen ? joined.slice(0, maxLen) : joined;
+}
+
+export {
+  getProjectRoot,
+  getProjectConfigPath,
+  getGlobalConfigPath,
+  resolveConfig,
+  configExists,
+  globalConfigExists,
+  projectConfigExists,
+  readConfig,
+  readGlobalConfig,
+  readProjectConfig,
+  writeConfig,
+  getApiKey,
+  getOpenAiApiKey,
+  getAccessControlFromAllSources,
+  getAccessControl,
+  getApiBase,
+  updateApiBase,
+  getCacheTtl,
+  updateAccessControl,
+  getWhoAmI,
+  updateWhoAmI,
+  ensureWhoAmI,
+  getEnvFromApiKey,
+  DEFAULT_MEMORY_CONFIG,
+  getMemoryConfig,
+  getMemoryConfigOrDefault,
+  memoryConfigExists,
+  updateMemoryConfig,
+  setOpenAiApiKey2 as setOpenAiApiKey,
+  embed,
+  embedBatch,
+  defaultSearchableText
+};