@withone/cli 1.47.6 → 1.47.8

package/dist/{chunk-SFGH6VAJ.js → chunk-KWGN3RJR.js}

@@ -1289,7 +1289,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-KL2ATVBD.js");
+  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-7VRNSKWU.js");
   const { flow: subFlow, rootDir: subRootDir } = loadFlowWithMeta2(resolvedKey);
   const subContext = await executeFlow(
     subFlow,
@@ -1503,16 +1503,17 @@ async function executeSingleStep(step, context, api, permissions, allowedActionI
   }
   const startTime = Date.now();
   let lastError;
-  const maxAttempts = step.onError?.strategy === "retry" && step.onError.retries ? step.onError.retries + 1 : 1;
+  const onError = step.onError ?? context._defaultOnError;
+  const maxAttempts = onError?.strategy === "retry" && onError.retries ? onError.retries + 1 : 1;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
       if (attempt > 1) {
-        const delay = computeRetryDelay(step.onError, attempt);
+        const delay = computeRetryDelay(onError, attempt);
         options.onEvent?.({
           event: "step:retry",
           stepId: step.id,
           attempt,
-          maxRetries: step.onError.retries,
+          maxRetries: onError.retries,
           delayMs: delay
         });
         await sleep2(delay);
@@ -1599,8 +1600,8 @@ async function executeSingleStep(step, context, api, permissions, allowedActionI
       if (attempt === maxAttempts) {
         break;
       }
-      if (step.onError?.strategy === "retry" && (step.onError.retryOn || step.onError.failFastOn)) {
-        const decision = shouldRetryError(lastError, step.onError);
+      if (onError?.strategy === "retry" && (onError.retryOn || onError.failFastOn)) {
+        const decision = shouldRetryError(lastError, onError);
         if (!decision.retry) {
           options.onEvent?.({
             event: "step:retry-skip",
@@ -1614,7 +1615,7 @@ async function executeSingleStep(step, context, api, permissions, allowedActionI
     }
   }
   const errorMessage = lastError?.message || "Unknown error";
-  const strategy = step.onError?.strategy || "fail";
+  const strategy = onError?.strategy || "fail";
   const retriesUsed = Math.max(0, maxAttempts - 1);
   const isTimeout = lastError instanceof StepTimeoutError;
   const errorCode = lastError?.errorCode;
@@ -1629,7 +1630,7 @@ async function executeSingleStep(step, context, api, permissions, allowedActionI
     context.steps[step.id] = result;
     return result;
   }
-  if (strategy === "fallback" && step.onError?.fallbackStepId) {
+  if (strategy === "fallback" && onError?.fallbackStepId) {
     const result = {
       status: isTimeout ? "timeout" : "failed",
       error: errorMessage,
@@ -1750,6 +1751,7 @@ async function executeFlow(flow, inputs, api, permissions, allowedActionIds, opt
     loop: {}
   };
   context.input = resolvedInputs;
+  context._defaultOnError = flow.defaultOnError;
   const completedStepIds = resumeState ? new Set(resumeState.completedSteps) : void 0;
   if (options.dryRun && !options.mock) {
     options.onEvent?.({
@@ -1807,7 +1809,8 @@ var FLOW_SCHEMA = {
     description: { type: "string", required: false, description: "What this flow does" },
     version: { type: "string", required: false, description: "Semver or arbitrary version string" },
     inputs: { type: "object", required: true, description: "Input declarations (Record<string, InputDeclaration>)" },
-    steps: { type: "array", required: true, description: "Ordered array of steps", stepsArray: true }
+    steps: { type: "array", required: true, description: "Ordered array of steps", stepsArray: true },
+    defaultOnError: { type: "object", required: false, description: 'Default error strategy inherited by every step without its own `onError` (e.g. { "strategy": "continue" }). A step opts out with its own `onError`.' }
   },
   inputFields: {
     type: { type: "string", required: true, description: "Data type: string, number, boolean, object, array", enum: ["string", "number", "boolean", "object", "array"] },

package/dist/{flow-runner-KL2ATVBD.js → flow-runner-7VRNSKWU.js}

@@ -12,7 +12,7 @@ import {
   stripStepsAlias,
   summarizeFlowInputs,
   walkSteps
-} from "./chunk-SFGH6VAJ.js";
+} from "./chunk-KWGN3RJR.js";
 import "./chunk-44CV5IMX.js";
 import "./chunk-K6MWE2ZH.js";
 export {

package/dist/index.js

@@ -30,7 +30,7 @@ import {
   searchCachePath,
   validateActionInput,
   writeCache
-} from "./chunk-SFGH6VAJ.js";
+} from "./chunk-KWGN3RJR.js";
 import {
   memSqlCommand
 } from "./chunk-QV3Y5N5G.js";
@@ -3101,6 +3101,16 @@ function validateFlowSchema(flow2) {
   if (f.version !== void 0 && typeof f.version !== "string") {
     errors.push({ path: "version", message: '"version" must be a string' });
   }
+  if (f.defaultOnError !== void 0) {
+    if (!f.defaultOnError || typeof f.defaultOnError !== "object" || Array.isArray(f.defaultOnError)) {
+      errors.push({ path: "defaultOnError", message: '"defaultOnError" must be an object (e.g. { "strategy": "continue" })' });
+    } else {
+      const oe = f.defaultOnError;
+      if (!FLOW_SCHEMA.errorStrategies.includes(oe.strategy)) {
+        errors.push({ path: "defaultOnError.strategy", message: `Error strategy must be one of: ${FLOW_SCHEMA.errorStrategies.join(", ")}` });
+      }
+    }
+  }
   if (!f.inputs || typeof f.inputs !== "object" || Array.isArray(f.inputs)) {
     errors.push({ path: "inputs", message: 'Flow must have an "inputs" object' });
   } else {
@@ -8290,6 +8300,10 @@ function registerSyncSubcommands(sync) {
   sync.command("sql <platform/model> <sql>").description("Run a read-only SELECT / WITH / EXPLAIN against the memory store (type-scoped helper)").action(async (platformModel, sql) => {
     await syncSqlCommand(platformModel, sql);
   });
+  sync.command("schema <platform/model>").description("Inspect the JSON structure of synced records (field paths, types, examples) \u2014 useful before writing `sync sql` queries").action(async (platformModel) => {
+    const { syncSchemaCommand } = await import("./schema-DXHEU47V.js");
+    await syncSchemaCommand(platformModel);
+  });
   sync.command("delete <platform/model>").description('Delete records from local sync data (e.g. one sync delete notion/pages --id "abc-123")').option("--id <value>", "Delete record by ID").option("--where <conditions>", 'Delete records matching conditions (e.g. "status=archived")').option("--where-sql <predicate>", `Delete using a raw SQL WHERE clause (e.g. "json_extract(data, '$.type') = 'promotion'")`).option("--yes", "Skip confirmation prompt").action(async (platformModel, options) => {
     await syncDeleteCommand(platformModel, options);
   });
@@ -10009,6 +10023,7 @@ one --agent sync run stripe
 one --agent mem sync run stripe                    # identical (alias)
 
 # 5. Query + search (read from memory)
+one --agent sync schema stripe/customers                            # inspect field paths/types first
 one --agent sync query stripe/balanceTransactions --where "status=available" --limit 20
 one --agent sync query stripe/customers --where 'address.city=SF'   # dotted --where paths
 one --agent sync search "refund" --platform stripe                  # hybrid FTS + semantic
@@ -10249,6 +10264,7 @@ Every \`sync X\` command is also exposed as \`mem sync X\` \u2014 same handlers,
 | \`sync suggest-searchable <plat>/<model>\` | Rank candidate \`memory.searchable\` paths by signal density; emits paste-ready config |
 | \`sync run <platform>\` | Sync data (\`--full-refresh\`, \`--since\`, \`--dry-run\`, \`--no-memory\`) |
 | \`sync query <plat>/<model>\` | Query memory with \`--where\` (dotted paths), \`--after/before\` |
+| \`sync schema <plat>/<model>\` | Inspect the JSON structure of synced records (field paths, types, examples) \u2014 run before writing \`--where\` / query paths |
 | \`sync search "<query>"\` | Hybrid FTS + semantic across all synced data |
 | \`sync list [platform]\` | Show profiles, record counts, freshness |
 | \`sync schedule add/list/status/remove/repair\` | Manage cron schedules |

package/dist/schema-DXHEU47V.js

@@ -0,0 +1,109 @@
+import {
+  isAgentMode,
+  note,
+  okJson,
+  requireMemoryInit
+} from "./chunk-HS5AHQ4V.js";
+import {
+  getBackend
+} from "./chunk-OADHUAEU.js";
+import "./chunk-TXTRXV74.js";
+import "./chunk-K6MWE2ZH.js";
+
+// src/lib/memory/sync/schema.ts
+import pc from "picocolors";
+var SAMPLE_SIZE = 100;
+function typeOf(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function exampleOf(v) {
+  if (typeof v === "string") return v.length > 60 ? `${v.slice(0, 57)}\u2026` : v;
+  return v;
+}
+function addPath(path, value, acc) {
+  const t = typeOf(value);
+  let typeLabel;
+  if (t === "array") {
+    const arr = value;
+    const elemType = arr.length ? typeOf(arr[0]) : "unknown";
+    typeLabel = `array[${elemType}]`;
+  } else {
+    typeLabel = t;
+  }
+  const entry = acc.get(path) ?? { types: /* @__PURE__ */ new Set(), hasExample: false, presence: 0 };
+  entry.types.add(typeLabel);
+  entry.presence += 1;
+  if (!entry.hasExample && t !== "object" && t !== "array" && value !== null && value !== void 0) {
+    entry.example = exampleOf(value);
+    entry.hasExample = true;
+  }
+  acc.set(path, entry);
+  if (t === "object") {
+    for (const [k, v] of Object.entries(value)) {
+      addPath(path ? `${path}.${k}` : k, v, acc);
+    }
+  } else if (t === "array") {
+    const arr = value;
+    if (arr.length && typeOf(arr[0]) === "object") {
+      for (const [k, v] of Object.entries(arr[0])) {
+        addPath(`${path}[].${k}`, v, acc);
+      }
+    }
+  }
+}
+function inferSyncSchema(dataRecords) {
+  const acc = /* @__PURE__ */ new Map();
+  for (const data of dataRecords) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) continue;
+    for (const [k, v] of Object.entries(data)) addPath(k, v, acc);
+  }
+  return [...acc.entries()].map(([path, e]) => ({
+    path,
+    types: [...e.types].sort(),
+    ...e.hasExample ? { example: e.example } : {},
+    presence: e.presence
+  })).sort((a, b) => a.path.localeCompare(b.path));
+}
+async function syncSchemaCommand(platformModel, _options = {}) {
+  requireMemoryInit();
+  const type = platformModel;
+  const backend = await getBackend();
+  let recordCount = 0;
+  try {
+    recordCount = await backend.count(type, { status: "active" });
+  } catch {
+  }
+  const records = await backend.list(type, { limit: SAMPLE_SIZE, status: "active" });
+  if (records.length === 0) {
+    if (isAgentMode()) {
+      okJson({ type, recordCount: 0, sampled: 0, fields: [] });
+      return;
+    }
+    note(`No records found for "${type}". Run \`one sync run <platform>\` first, or check \`one --agent sync status\`.`, "Schema");
+    return;
+  }
+  const fields = inferSyncSchema(records.map((r) => r.data));
+  if (isAgentMode()) {
+    okJson({ type, recordCount, sampled: records.length, fields });
+    return;
+  }
+  console.log();
+  console.log(`${pc.bold(type)} ${pc.dim(`(${recordCount.toLocaleString()} record${recordCount === 1 ? "" : "s"}, sampled ${records.length})`)}`);
+  console.log();
+  const pathWidth = Math.min(Math.max(...fields.map((f) => f.path.length), 4) + 2, 50);
+  const typeWidth = Math.max(...fields.map((f) => f.types.join("|").length), 4) + 2;
+  for (const f of fields) {
+    const optional = f.presence < records.length ? pc.yellow(" ?") : "";
+    const ex = f.example !== void 0 ? pc.dim(JSON.stringify(f.example)) : "";
+    console.log(`  ${f.path.padEnd(pathWidth)}${pc.cyan(f.types.join("|").padEnd(typeWidth))}${ex}${optional}`);
+  }
+  console.log();
+  console.log(pc.dim(`  ? = present in only some sampled records (optional/sparse field)`));
+  console.log();
+}
+export {
+  inferSyncSchema,
+  syncSchemaCommand
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withone/cli",
-  "version": "1.47.6",
+  "version": "1.47.8",
   "description": "CLI for managing One",
   "type": "module",
   "files": [

package/skills/one/SKILL.md

@@ -229,6 +229,7 @@ one --agent sync test attio/attioPeople --show-searchable
 
 # Run — memory is always written; pass --no-memory to skip (rare)
 one --agent sync run stripe
+one --agent sync schema stripe/customers         # inspect field paths/types before querying
 one --agent sync query stripe/balanceTransactions --where "status=available" --limit 20
 one --agent sync search "refund"                 # hybrid across all synced platforms
 one --agent sync list stripe                     # progress + freshness

package/skills/one/references/flows.md

@@ -566,6 +566,22 @@ the outputSchema declaration.
 
 Strategies: `fail` (default), `continue`, `retry`, `fallback`.
 
+**Flow-level default (cli#93).** Set `defaultOnError` at the top of the flow and every step without its own `onError` inherits it — handy when most steps should `continue` (e.g. rendering/formatting pipelines) and you don't want to repeat it N times. A step opts out by declaring its own `onError`:
+
+```json
+{
+  "key": "render-report",
+  "defaultOnError": { "strategy": "continue" },
+  "steps": [
+    { "id": "critical", "onError": { "strategy": "fail" }, ... },   // stays fatal
+    { "id": "chart", ... },                                          // inherits continue
+    { "id": "thumbnail", ... }                                       // inherits continue
+  ]
+}
+```
+
+Scoped per-flow: a sub-flow uses its own `defaultOnError`, not the parent's.
+
 **Retry backoff.** By default each retry waits exactly `retryDelayMs`. For rate-limited APIs add `"backoff": "exponential"` (or `"exponential-jitter"`) and an optional `"maxDelayMs"` cap (defaults to 30000):
 
 ```json