@withone/cli 1.44.1 → 1.45.0

package/dist/{chunk-YGOS6KEC.js → chunk-UXKF6AEG.js}

@@ -2,16 +2,19 @@ import {
   getByDotPath,
   setByDotPath
 } from "./chunk-44CV5IMX.js";
+import {
+  getCacheTtl
+} from "./chunk-TVIZC7AC.js";
 
 // src/lib/flow-runner.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import crypto from "crypto";
 
 // src/lib/flow-engine.ts
-import fs from "fs";
-import os from "os";
-import path from "path";
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
 import { exec, spawn } from "child_process";
 import { promisify } from "util";
 
@@ -45,8 +48,8 @@ var OneApi = class {
     this.apiBase = apiBase ?? "https://api.withone.ai/v1";
   }
   apiBase;
-  async request(path3) {
-    return this.requestFull({ path: path3 });
+  async request(path4) {
+    return this.requestFull({ path: path4 });
   }
   async requestFull(opts) {
     let url = `${this.apiBase}${opts.path}`;
@@ -231,7 +234,12 @@ var OneApi = class {
     const data = text ? JSON.parse(text) : {};
     return { data, etag, status: response.status };
   }
-  async getActionKnowledgeWithMeta(actionId, ifNoneMatch) {
+  /**
+   * Full action details (method, path, tags, ioSchema, knowledge) with ETag
+   * support. This is what the knowledge cache stores: caching the complete
+   * object lets `actions execute` reuse it and skip its preflight round trip.
+   */
+  async getActionDetailsWithMeta(actionId, ifNoneMatch) {
     const result = await this.requestWithMeta({
       path: "/knowledge",
       queryParams: { _id: actionId },
@@ -244,12 +252,7 @@ var OneApi = class {
     if (actions.length === 0) {
       throw new ApiError(404, `Action with ID ${actionId} not found`);
     }
-    const action = actions[0];
-    const knowledge = {
-      knowledge: action.knowledge || "No knowledge was found",
-      method: action.method || "No method was found"
-    };
-    return { data: knowledge, etag: result.etag, status: result.status };
+    return { data: actions[0], etag: result.etag, status: result.status };
   }
   async searchActionsWithMeta(platform, query, agentType, ifNoneMatch) {
     const isKnowledgeAgent = agentType === "knowledge";
@@ -478,9 +481,9 @@ var TimeoutError = class extends Error {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-function replacePathVariables(path3, variables) {
-  if (!path3) return path3;
-  let result = path3;
+function replacePathVariables(path4, variables) {
+  if (!path4) return path4;
+  let result = path4;
   result = result.replace(/\{\{([^}]+)\}\}/g, (_match, variable) => {
     const trimmedVariable = variable.trim();
     const value = variables[trimmedVariable];
@@ -544,6 +547,159 @@ Read the API documentation below to identify which parameters are path variables
 ${knowledge}`;
 }
 
+// src/lib/cache.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function knowledgeDir() {
+  return path.join(os.homedir(), ".one", "cache", "knowledge");
+}
+function searchDir() {
+  return path.join(os.homedir(), ".one", "cache", "search");
+}
+function sanitizeFilename(input) {
+  return input.replace(/[^a-zA-Z0-9_\-\.]/g, "_");
+}
+function knowledgeCachePath(actionId) {
+  return path.join(knowledgeDir(), `${sanitizeFilename(actionId)}.json`);
+}
+function searchCachePath(platform, query, type) {
+  const key = `${platform}_${sanitizeFilename(query)}_${type || "knowledge"}`;
+  return path.join(searchDir(), `${key}.json`);
+}
+function readCache(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeCache(filePath, entry) {
+  try {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(entry, null, 2));
+  } catch {
+  }
+}
+function isFresh(entry) {
+  const cachedTime = new Date(entry.cachedAt).getTime();
+  const now = Date.now();
+  return now - cachedTime < entry.ttl * 1e3;
+}
+function getAge(entry) {
+  return Math.floor((Date.now() - new Date(entry.cachedAt).getTime()) / 1e3);
+}
+function buildCacheMeta(entry, hit) {
+  if (!entry) {
+    return { hit: false, age: 0, fresh: false };
+  }
+  return {
+    hit,
+    age: getAge(entry),
+    fresh: isFresh(entry)
+  };
+}
+function formatAge(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) {
+    const h2 = Math.floor(seconds / 3600);
+    const m = Math.floor(seconds % 3600 / 60);
+    return m > 0 ? `${h2}h ${m}m` : `${h2}h`;
+  }
+  const d = Math.floor(seconds / 86400);
+  const h = Math.floor(seconds % 86400 / 3600);
+  return h > 0 ? `${d}d ${h}h` : `${d}d`;
+}
+function listCacheEntries() {
+  const entries = [];
+  for (const [dir, type] of [[knowledgeDir(), "knowledge"], [searchDir(), "search"]]) {
+    try {
+      const files = fs.readdirSync(dir);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const filePath = path.join(dir, file);
+        const entry = readCache(filePath);
+        if (entry) {
+          entries.push({ type, filePath, entry });
+        }
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function clearAll() {
+  let count = 0;
+  for (const dir of [knowledgeDir(), searchDir()]) {
+    try {
+      const files = fs.readdirSync(dir);
+      for (const file of files) {
+        fs.unlinkSync(path.join(dir, file));
+        count++;
+      }
+      fs.rmdirSync(dir);
+    } catch {
+    }
+  }
+  return count;
+}
+function clearEntry(actionId) {
+  const filePath = knowledgeCachePath(actionId);
+  try {
+    fs.unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function makeCacheEntry(key, data, etag) {
+  return {
+    key,
+    etag,
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ttl: getCacheTtl(),
+    data
+  };
+}
+
+// src/lib/action-details.ts
+function isActionDetailsEntry(entry) {
+  const data = entry?.data;
+  return !!data && typeof data._id === "string" && typeof data.path === "string" && typeof data.method === "string";
+}
+async function resolveActionDetails(api, actionId, opts = {}) {
+  const useCache = opts.useCache !== false;
+  const cachePath = knowledgeCachePath(actionId);
+  const raw = useCache ? readCache(cachePath) : null;
+  const cached = isActionDetailsEntry(raw) ? raw : null;
+  if (cached && isFresh(cached)) {
+    return { details: cached.data, cacheHit: true, entry: cached };
+  }
+  try {
+    const result = await api.getActionDetailsWithMeta(actionId, cached?.etag ?? void 0);
+    if (result.status === 304 && cached) {
+      cached.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
+      writeCache(cachePath, cached);
+      return { details: cached.data, cacheHit: true, entry: cached };
+    }
+    const entry = makeCacheEntry(actionId, result.data, result.etag);
+    writeCache(cachePath, entry);
+    return { details: result.data, cacheHit: false, entry };
+  } catch (fetchError) {
+    if (cached) {
+      process.stderr.write(
+        `Warning: serving cached action details (network unavailable, cached ${formatAge(getAge(cached))} ago)
+`
+      );
+      return { details: cached.data, cacheHit: true, entry: cached };
+    }
+    throw fetchError;
+  }
+}
+
 // src/lib/validate.ts
 var SCHEMA_GROUP_TO_FLAG = {
   path: "--path-vars",
@@ -816,7 +972,7 @@ async function executeActionStep(step, context, api, permissions, allowedActionI
   if (!isActionAllowed(actionId, allowedActionIds)) {
     throw new Error(`Action "${actionId}" is not in the allowed action list`);
   }
-  const actionDetails = await api.getActionDetails(actionId);
+  const { details: actionDetails } = await resolveActionDetails(api, actionId);
   if (!isMethodAllowed(actionDetails.method, permissions)) {
     throw new Error(`Method "${actionDetails.method}" is not allowed under "${permissions}" permission level`);
   }
@@ -899,15 +1055,15 @@ async function executeCodeModule(stepId, modulePath, context, options) {
   if (!rootDir) {
     throw new Error(`Code step "${stepId}" uses module "${modulePath}" but no flow rootDir is available. Flows that use code modules must be loaded via loadFlowWithMeta.`);
   }
-  if (path.isAbsolute(modulePath)) {
+  if (path2.isAbsolute(modulePath)) {
     throw new Error(`Code module path must be relative to the flow root, got absolute: "${modulePath}"`);
   }
-  const absPath = path.resolve(rootDir, modulePath);
-  const relFromRoot = path.relative(rootDir, absPath);
-  if (relFromRoot.startsWith("..") || path.isAbsolute(relFromRoot)) {
+  const absPath = path2.resolve(rootDir, modulePath);
+  const relFromRoot = path2.relative(rootDir, absPath);
+  if (relFromRoot.startsWith("..") || path2.isAbsolute(relFromRoot)) {
     throw new Error(`Code module "${modulePath}" resolves outside the flow directory`);
   }
-  if (!fs.existsSync(absPath)) {
+  if (!fs2.existsSync(absPath)) {
     throw new Error(`Code module not found: ${absPath}`);
   }
   const { env: _omitEnv, ...safeContext } = context;
@@ -1055,8 +1211,8 @@ async function executeParallelStep(step, context, api, permissions, allowedActio
 function executeFileReadStep(step, context) {
   const config = step.fileRead;
   const filePath = resolveValue(config.path, context);
-  const resolvedPath = path.resolve(filePath);
-  const content = fs.readFileSync(resolvedPath, "utf-8");
+  const resolvedPath = path2.resolve(filePath);
+  const content = fs2.readFileSync(resolvedPath, "utf-8");
   const output = config.parseJson ? JSON.parse(stripCodeFences(content)) : content;
   return { status: "success", output, response: output };
 }
@@ -1064,16 +1220,16 @@ function executeFileWriteStep(step, context) {
   const config = step.fileWrite;
   const filePath = resolveValue(config.path, context);
   const content = resolveValue(config.content, context);
-  const resolvedPath = path.resolve(filePath);
-  const dir = path.dirname(resolvedPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+  const resolvedPath = path2.resolve(filePath);
+  const dir = path2.dirname(resolvedPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
   }
   const stringContent = typeof content === "string" ? content : JSON.stringify(content, null, 2);
   if (config.append) {
-    fs.appendFileSync(resolvedPath, stringContent);
+    fs2.appendFileSync(resolvedPath, stringContent);
   } else {
-    fs.writeFileSync(resolvedPath, stringContent);
+    fs2.writeFileSync(resolvedPath, stringContent);
   }
   return { status: "success", output: { path: resolvedPath, bytesWritten: stringContent.length }, response: { path: resolvedPath } };
 }
@@ -1112,7 +1268,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-EXZ77YLF.js");
+  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-FQVTF36N.js");
   const { flow: subFlow, rootDir: subRootDir } = loadFlowWithMeta2(resolvedKey);
   const subContext = await executeFlow(
     subFlow,
@@ -1215,11 +1371,11 @@ function resolveBashEnv(envConfig, context, stepId) {
       if ("json" in obj) {
         const resolved2 = resolveValue(obj.json, context);
         const json = JSON.stringify(resolved2 ?? null);
-        const tmp = path.join(
-          os.tmpdir(),
+        const tmp = path2.join(
+          os2.tmpdir(),
           `one-flow-${stepId}-${key}-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`
         );
-        fs.writeFileSync(tmp, json, { encoding: "utf-8" });
+        fs2.writeFileSync(tmp, json, { encoding: "utf-8" });
         tempFiles.push(tmp);
         out[key] = tmp;
         continue;
@@ -1266,7 +1422,7 @@ async function executeBashStep(step, context, options) {
   } finally {
     for (const tmp of tempFiles) {
       try {
-        fs.unlinkSync(tmp);
+        fs2.unlinkSync(tmp);
       } catch {
       }
     }
@@ -1347,7 +1503,7 @@ async function executeSingleStep(step, context, api, permissions, allowedActionI
         if (step.type === "action" && step.action) {
           const actionId = resolveValue(step.action.actionId, context);
           try {
-            const actionDetails = await api.getActionDetails(actionId);
+            const { details: actionDetails } = await resolveActionDetails(api, actionId);
             if (!options.skipValidation) {
               const data = step.action.data ? resolveValue(step.action.data, context) : void 0;
               const pathVars = step.action.pathVars ? resolveValue(step.action.pathVars, context) : void 0;
@@ -2389,8 +2545,8 @@ var FLOWS_DIR = ".one/flows";
 var RUNS_DIR = ".one/flows/.runs";
 var LOGS_DIR = ".one/flows/.logs";
 function ensureDir(dir) {
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
   }
 }
 function generateRunId() {
@@ -2408,8 +2564,8 @@ var FlowRunner = class _FlowRunner {
     this.flowKey = flow.key;
     ensureDir(RUNS_DIR);
     ensureDir(LOGS_DIR);
-    this.statePath = path2.join(RUNS_DIR, `${flow.key}-${this.runId}.state.json`);
-    this.logPath = path2.join(LOGS_DIR, `${flow.key}-${this.runId}.log`);
+    this.statePath = path3.join(RUNS_DIR, `${flow.key}-${this.runId}.state.json`);
+    this.logPath = path3.join(LOGS_DIR, `${flow.key}-${this.runId}.log`);
     const resolvedInputs = { ...inputs };
     for (const [name, decl] of Object.entries(flow.inputs)) {
       if (resolvedInputs[name] === void 0 && decl.default !== void 0) {
@@ -2450,10 +2606,10 @@ var FlowRunner = class _FlowRunner {
       msg,
       ...data
     };
-    fs2.appendFileSync(this.logPath, JSON.stringify(entry) + "\n");
+    fs3.appendFileSync(this.logPath, JSON.stringify(entry) + "\n");
   }
   saveState() {
-    fs2.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+    fs3.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
   }
   createEventHandler(externalHandler) {
     return (event) => {
@@ -2551,10 +2707,10 @@ var FlowRunner = class _FlowRunner {
   }
   static loadRunState(runId) {
     ensureDir(RUNS_DIR);
-    const files = fs2.readdirSync(RUNS_DIR).filter((f) => f.includes(runId) && f.endsWith(".state.json"));
+    const files = fs3.readdirSync(RUNS_DIR).filter((f) => f.includes(runId) && f.endsWith(".state.json"));
     if (files.length === 0) return null;
     try {
-      const content = fs2.readFileSync(path2.join(RUNS_DIR, files[0]), "utf-8");
+      const content = fs3.readFileSync(path3.join(RUNS_DIR, files[0]), "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -2566,17 +2722,17 @@ var FlowRunner = class _FlowRunner {
     runner.flowKey = state.flowKey;
     runner.state = state;
     runner.paused = false;
-    runner.statePath = path2.join(RUNS_DIR, `${state.flowKey}-${state.runId}.state.json`);
-    runner.logPath = path2.join(LOGS_DIR, `${state.flowKey}-${state.runId}.log`);
+    runner.statePath = path3.join(RUNS_DIR, `${state.flowKey}-${state.runId}.state.json`);
+    runner.logPath = path3.join(LOGS_DIR, `${state.flowKey}-${state.runId}.log`);
     return runner;
   }
   static listRuns(flowKey) {
     ensureDir(RUNS_DIR);
-    const files = fs2.readdirSync(RUNS_DIR).filter((f) => f.endsWith(".state.json"));
+    const files = fs3.readdirSync(RUNS_DIR).filter((f) => f.endsWith(".state.json"));
     const runs = [];
     for (const file of files) {
       try {
-        const content = fs2.readFileSync(path2.join(RUNS_DIR, file), "utf-8");
+        const content = fs3.readFileSync(path3.join(RUNS_DIR, file), "utf-8");
         const state = JSON.parse(content);
         if (!flowKey || state.flowKey === flowKey) {
           runs.push(state);
@@ -2589,44 +2745,44 @@ var FlowRunner = class _FlowRunner {
 };
 function resolveFlowPath(keyOrPath) {
   if (keyOrPath.endsWith(".json")) {
-    return path2.resolve(keyOrPath);
+    return path3.resolve(keyOrPath);
   }
   if (keyOrPath.includes("\\")) {
-    return path2.resolve(keyOrPath);
+    return path3.resolve(keyOrPath);
   }
   if (keyOrPath.includes("/")) {
-    const nestedFolder = path2.resolve(FLOWS_DIR, keyOrPath, "flow.json");
-    if (fs2.existsSync(nestedFolder)) return nestedFolder;
-    const literal = path2.resolve(keyOrPath);
-    if (fs2.existsSync(literal)) return literal;
+    const nestedFolder = path3.resolve(FLOWS_DIR, keyOrPath, "flow.json");
+    if (fs3.existsSync(nestedFolder)) return nestedFolder;
+    const literal = path3.resolve(keyOrPath);
+    if (fs3.existsSync(literal)) return literal;
     return nestedFolder;
   }
-  const folderPath = path2.resolve(FLOWS_DIR, keyOrPath, "flow.json");
-  if (fs2.existsSync(folderPath)) return folderPath;
-  const legacyPath = path2.resolve(FLOWS_DIR, `${keyOrPath}.flow.json`);
-  if (fs2.existsSync(legacyPath)) return legacyPath;
-  const flowsDir = path2.resolve(FLOWS_DIR);
-  if (fs2.existsSync(flowsDir)) {
-    for (const entry of fs2.readdirSync(flowsDir, { withFileTypes: true })) {
+  const folderPath = path3.resolve(FLOWS_DIR, keyOrPath, "flow.json");
+  if (fs3.existsSync(folderPath)) return folderPath;
+  const legacyPath = path3.resolve(FLOWS_DIR, `${keyOrPath}.flow.json`);
+  if (fs3.existsSync(legacyPath)) return legacyPath;
+  const flowsDir = path3.resolve(FLOWS_DIR);
+  if (fs3.existsSync(flowsDir)) {
+    for (const entry of fs3.readdirSync(flowsDir, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const nested = path2.join(flowsDir, entry.name, keyOrPath, "flow.json");
-      if (fs2.existsSync(nested)) return nested;
+      const nested = path3.join(flowsDir, entry.name, keyOrPath, "flow.json");
+      if (fs3.existsSync(nested)) return nested;
     }
   }
   return folderPath;
 }
 function getFlowRootDir(flowFilePath) {
-  const dir = path2.dirname(flowFilePath);
-  const base = path2.basename(flowFilePath);
+  const dir = path3.dirname(flowFilePath);
+  const base = path3.basename(flowFilePath);
   if (base === "flow.json") return dir;
   return dir;
 }
 function loadFlowWithMeta(keyOrPath) {
   const filePath = resolveFlowPath(keyOrPath);
-  if (!fs2.existsSync(filePath)) {
+  if (!fs3.existsSync(filePath)) {
     throw new Error(`Flow not found: ${filePath}`);
   }
-  const content = fs2.readFileSync(filePath, "utf-8");
+  const content = fs3.readFileSync(filePath, "utf-8");
   const flow = JSON.parse(content);
   return { flow, filePath, rootDir: getFlowRootDir(filePath) };
 }
@@ -2673,13 +2829,13 @@ function summarizeFlowInputs(flow) {
   }));
 }
 function listFlows() {
-  const flowsDir = path2.resolve(FLOWS_DIR);
-  if (!fs2.existsSync(flowsDir)) return [];
+  const flowsDir = path3.resolve(FLOWS_DIR);
+  if (!fs3.existsSync(flowsDir)) return [];
   const flows = [];
   const seenKeys = /* @__PURE__ */ new Set();
   const readFlowFile = (filePath, group) => {
     try {
-      const content = fs2.readFileSync(filePath, "utf-8");
+      const content = fs3.readFileSync(filePath, "utf-8");
       const flow = JSON.parse(content);
       const nsKey = group ? `${group}/${flow.key}` : flow.key;
       if (seenKeys.has(nsKey)) return;
@@ -2691,7 +2847,7 @@ function listFlows() {
         inputCount: Object.keys(flow.inputs).length,
         stepCount: flow.steps.length,
         path: filePath,
-        layout: path2.basename(filePath) === "flow.json" ? "folder" : "legacy",
+        layout: path3.basename(filePath) === "flow.json" ? "folder" : "legacy",
         group,
         stepTypes: collectStepTypes(flow),
         requiresBash: flowRequiresBash(flow),
@@ -2702,12 +2858,12 @@ function listFlows() {
     }
   };
   const scanDir = (dir, group) => {
-    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) continue;
-      const full = path2.join(dir, entry.name);
+      const full = path3.join(dir, entry.name);
       if (entry.isDirectory()) {
-        const flowJson = path2.join(full, "flow.json");
-        if (fs2.existsSync(flowJson)) {
+        const flowJson = path3.join(full, "flow.json");
+        if (fs3.existsSync(flowJson)) {
           readFlowFile(flowJson, group);
         } else {
           if (!group) {
@@ -2725,7 +2881,7 @@ function listFlows() {
 function saveFlow(flow, outputPath, group) {
   let flowPath;
   if (outputPath) {
-    flowPath = path2.resolve(outputPath);
+    flowPath = path3.resolve(outputPath);
   } else {
     let bareKey = flow.key;
     let resolvedGroup = group;
@@ -2735,21 +2891,21 @@ function saveFlow(flow, outputPath, group) {
       resolvedGroup = resolvedGroup || parts.join("/");
       flow.key = bareKey;
     }
-    const basePath = resolvedGroup ? path2.resolve(FLOWS_DIR, resolvedGroup, bareKey) : path2.resolve(FLOWS_DIR, bareKey);
-    const legacyPath = path2.resolve(FLOWS_DIR, `${bareKey}.flow.json`);
-    const folderPath = path2.join(basePath, "flow.json");
-    if (!resolvedGroup && fs2.existsSync(legacyPath) && !fs2.existsSync(folderPath)) {
+    const basePath = resolvedGroup ? path3.resolve(FLOWS_DIR, resolvedGroup, bareKey) : path3.resolve(FLOWS_DIR, bareKey);
+    const legacyPath = path3.resolve(FLOWS_DIR, `${bareKey}.flow.json`);
+    const folderPath = path3.join(basePath, "flow.json");
+    if (!resolvedGroup && fs3.existsSync(legacyPath) && !fs3.existsSync(folderPath)) {
       flowPath = legacyPath;
     } else {
       flowPath = folderPath;
     }
   }
-  const dir = path2.dirname(flowPath);
+  const dir = path3.dirname(flowPath);
   ensureDir(dir);
-  if (path2.basename(flowPath) === "flow.json") {
-    ensureDir(path2.join(dir, "lib"));
+  if (path3.basename(flowPath) === "flow.json") {
+    ensureDir(path3.join(dir, "lib"));
   }
-  fs2.writeFileSync(flowPath, JSON.stringify(flow, null, 2) + "\n");
+  fs3.writeFileSync(flowPath, JSON.stringify(flow, null, 2) + "\n");
   return flowPath;
 }
 
@@ -2762,6 +2918,19 @@ export {
   isActionAllowed,
   buildActionKnowledgeWithGuidance,
   validateActionInput,
+  knowledgeCachePath,
+  searchCachePath,
+  readCache,
+  writeCache,
+  isFresh,
+  getAge,
+  buildCacheMeta,
+  formatAge,
+  listCacheEntries,
+  clearAll,
+  clearEntry,
+  makeCacheEntry,
+  resolveActionDetails,
   FLOW_SCHEMA,
   getStepTypeDescriptor,
   getNestedStepsKeys,

package/dist/{chunk-VQPV5XET.js → chunk-Z4HKASJT.js}

@@ -6,11 +6,11 @@ import {
   note,
   okJson,
   requireMemoryInit
-} from "./chunk-MNNKOQ6V.js";
+} from "./chunk-KH4ERRJ5.js";
 import {
   getBackend,
   upsertRecord
-} from "./chunk-YBEVCY4D.js";
+} from "./chunk-TGWQUBKA.js";
 
 // src/commands/mem/migrate.ts
 import fs4 from "fs";

package/dist/{embedding-GZGDGIUA.js → embedding-C3E4EAQ7.js}

@@ -2,7 +2,8 @@ import {
   defaultSearchableText,
   embed,
   embedBatch
-} from "./chunk-ZD5S4IWT.js";
+} from "./chunk-77564KWS.js";
+import "./chunk-TVIZC7AC.js";
 export {
   defaultSearchableText,
   embed,

package/dist/{flow-runner-EXZ77YLF.js → flow-runner-FQVTF36N.js}

@@ -11,8 +11,9 @@ import {
   saveFlow,
   summarizeFlowInputs,
   walkSteps
-} from "./chunk-YGOS6KEC.js";
+} from "./chunk-UXKF6AEG.js";
 import "./chunk-44CV5IMX.js";
+import "./chunk-TVIZC7AC.js";
 export {
   FlowRunner,
   collectStepTypes,