@withone/cli 1.42.0 → 1.43.2

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
+};

package/dist/{chunk-PK2RAVAF.js → chunk-EMAQVPRD.js}

@@ -1,3 +1,8 @@
+import {
+  getByDotPath,
+  setByDotPath
+} from "./chunk-44CV5IMX.js";
+
 // src/lib/flow-runner.ts
 import fs2 from "fs";
 import path2 from "path";
@@ -571,40 +576,6 @@ function validateActionInput(action, args) {
   return { valid: false, missing };
 }
 
-// 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;
-}
-
 // src/lib/flow-engine.ts
 var execAsync = promisify(exec);
 function sleep2(ms) {
@@ -1140,7 +1111,7 @@ async function executeSubflowStep(step, context, api, permissions, allowedAction
   if (flowStack.includes(resolvedKey)) {
     throw new Error(`Circular flow detected: ${[...flowStack, resolvedKey].join(" \u2192 ")}`);
   }
-  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-Y2CXXU3U.js");
+  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-XSJ4US5S.js");
   const { flow: subFlow, rootDir: subRootDir } = loadFlowWithMeta2(resolvedKey);
   const subContext = await executeFlow(
     subFlow,
@@ -2794,7 +2765,6 @@ export {
   getStepTypeDescriptor,
   getNestedStepsKeys,
   generateFlowGuide,
-  getByDotPath,
   FlowRunner,
   resolveFlowPath,
   getFlowRootDir,

package/dist/chunk-MRGKKO54.js

@@ -0,0 +1,158 @@
+import {
+  getMemoryConfigOrDefault,
+  getOpenAiApiKey,
+  readConfig
+} from "./chunk-AU2ZEEMS.js";
+
+// src/lib/output.ts
+import * as p from "@clack/prompts";
+var _agentMode = false;
+function setAgentMode(value) {
+  _agentMode = value;
+}
+function isAgentMode() {
+  return _agentMode || process.env.ONE_AGENT === "1";
+}
+function createSpinner() {
+  if (isAgentMode()) {
+    return { start() {
+    }, stop() {
+    } };
+  }
+  return p.spinner();
+}
+function intro2(msg) {
+  if (!isAgentMode()) p.intro(msg);
+}
+function outro2(msg) {
+  if (!isAgentMode()) p.outro(msg);
+}
+function note2(msg, title) {
+  if (!isAgentMode()) p.note(msg, title);
+}
+function cancel2(msg) {
+  if (!isAgentMode()) p.cancel(msg);
+}
+function json(data) {
+  process.stdout.write(JSON.stringify(data) + "\n");
+}
+function error(message, exitCode = 1) {
+  if (isAgentMode()) {
+    json({ error: message });
+  } else {
+    p.cancel(message);
+  }
+  process.exit(exitCode);
+}
+
+// src/commands/mem/util.ts
+function requireMemoryInit() {
+  if (!readConfig()) {
+    error("No One config found. Run `one init` first.");
+  }
+}
+function parseJsonArg(arg, field = "data") {
+  try {
+    const parsed = JSON.parse(arg);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      error(`${field} must be a JSON object, not ${Array.isArray(parsed) ? "an array" : typeof parsed}.`);
+    }
+    return parsed;
+  } catch (err) {
+    error(`Invalid JSON for ${field}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function parseCsv(value) {
+  if (!value) return void 0;
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function parsePositiveInt(value, fallback, label = "value") {
+  if (value === void 0) return fallback;
+  const n = Number.parseInt(value, 10);
+  if (!Number.isFinite(n) || n <= 0) {
+    error(`${label} must be a positive integer`);
+  }
+  return n;
+}
+function printRecord(record) {
+  if (isAgentMode()) {
+    json(record);
+    return;
+  }
+  console.log(JSON.stringify(record, null, 2));
+}
+function printList(items) {
+  if (isAgentMode()) {
+    json({ items, total: items.length });
+    return;
+  }
+  if (items.length === 0) {
+    console.log("(no results)");
+    return;
+  }
+  console.log(JSON.stringify(items, null, 2));
+}
+function okJson(payload) {
+  if (isAgentMode()) {
+    json(payload);
+    return;
+  }
+  console.log(JSON.stringify(payload, null, 2));
+}
+function semanticSearchUpgradeHint(opts = {}) {
+  const cfg = getMemoryConfigOrDefault();
+  const keyPresent = !!getOpenAiApiKey();
+  const providerOn = cfg.embedding.provider === "openai";
+  if (opts.vectorSearchAvailable === false) {
+    return {
+      capability: "semantic_search",
+      available: true,
+      currentMode: "fts_only",
+      how: "Install pgvector for the bundled Postgres: `brew install pgvector` (or point at a remote Postgres with pgvector via `one mem config set backend postgres`)",
+      benefit: "Ranks memories by meaning, not just keyword overlap \u2014 finds relevant records even when the query and the data use different words."
+    };
+  }
+  if (providerOn && keyPresent) return null;
+  if (!keyPresent) {
+    return {
+      capability: "semantic_search",
+      available: true,
+      currentMode: "fts_only",
+      how: 'Add an OpenAI key: `one init` (then "Add OpenAI key"), or `one mem config set embedding.apiKey sk-...`',
+      benefit: "Ranks memories by meaning, not just keyword overlap \u2014 finds relevant records even when the query and the data use different words."
+    };
+  }
+  return {
+    capability: "semantic_search",
+    available: true,
+    currentMode: "fts_only",
+    how: "Flip the provider on: `one mem config set embedding.provider openai`",
+    benefit: "Ranks memories by meaning, not just keyword overlap."
+  };
+}
+function semanticSearchUpgradeLine(opts = {}) {
+  const hint = semanticSearchUpgradeHint(opts);
+  if (!hint) return "";
+  return `tip: semantic search available \u2014 ${hint.how}`;
+}
+
+export {
+  setAgentMode,
+  isAgentMode,
+  createSpinner,
+  intro2 as intro,
+  outro2 as outro,
+  note2 as note,
+  cancel2 as cancel,
+  json,
+  error,
+  requireMemoryInit,
+  parseJsonArg,
+  parseCsv,
+  parsePositiveInt,
+  printRecord,
+  printList,
+  okJson,
+  semanticSearchUpgradeHint,
+  semanticSearchUpgradeLine
+};

package/dist/embedding-O4XWBL6T.js

@@ -0,0 +1,10 @@
+import {
+  defaultSearchableText,
+  embed,
+  embedBatch
+} from "./chunk-AU2ZEEMS.js";
+export {
+  defaultSearchableText,
+  embed,
+  embedBatch
+};