@lostgradient/weft 0.2.0

package/dist/cli/operation-catalog-snapshot.js

@@ -0,0 +1,48 @@
+import { definitionSchemaToJsonSchema } from "../core/types/definition-schema-to-json.js";
+import { compareStrings, normalizeJsonObject } from "../server/json-schema-utilities.js";
+import { createLiveOperationRegistry } from "../server/rest-bindings.js";
+export function createCatalogSnapshot() {
+  return {
+    generatedBy: "weft catalog snapshot",
+    version: 1,
+    operations: createLiveOperationRegistry().list().map(operationToSnapshot).toSorted((left, right) => compareStrings(left.name, right.name))
+  };
+}
+export function stringifyCatalogSnapshot(snapshot) {
+  return `${JSON.stringify(snapshot, null, 2)}
+`;
+}
+function operationToSnapshot(operation) {
+  const eventSchema = operation.eventSchema;
+  return {
+    name: operation.name,
+    kind: operation.kind ?? "unary",
+    summary: operation.summary,
+    ...operation.description === void 0 ? {} : { description: operation.description },
+    tags: [...operation.tags].toSorted(compareStrings),
+    destructive: operation.destructive ?? !1,
+    access: accessToSnapshot(operation.access),
+    transports: { ...operation.transports },
+    producibleFaults: [...operation.producibleFaults ?? []].toSorted(compareStrings),
+    inputSchema: normalizeJsonObject(definitionSchemaToJsonSchema(operation.inputSchema, "input")),
+    outputSchema: normalizeJsonObject(definitionSchemaToJsonSchema(operation.outputSchema, "output")),
+    ...eventSchema === void 0 ? {} : { eventSchema: normalizeJsonObject(definitionSchemaToJsonSchema(eventSchema, "output")) }
+  };
+}
+function accessToSnapshot(access) {
+  if (access.kind === "public")
+    return { kind: "public" };
+  if (access.kind === "authenticated")
+    return { kind: "authenticated" };
+  if (access.kind === "scoped")
+    return { kind: "scoped", scopes: [...access.scopes.scopes].toSorted(compareStrings) };
+  if (access.kind === "optionalAuth")
+    return {
+      kind: "optionalAuth",
+      scopes: [...access.authenticatedScopes.scopes].toSorted(compareStrings)
+    };
+  return {
+    kind: "scopedAlternatives",
+    alternatives: access.alternatives.map((alternative) => [...alternative.scopes].toSorted(compareStrings))
+  };
+}

package/dist/cli/operation-client-runtime.d.ts

@@ -0,0 +1,47 @@
+import type { ConnectionOptions } from '../connection.ts';
+import { type JsonRpcErrorObject } from './json-rpc-client.ts';
+/**
+ * Error thrown by the catalog client when an operation call returns a JSON-RPC
+ * error. Carries the wire `code` so hand-authored commands can distinguish
+ * version-skew (operation absent on an older server) from domain faults without
+ * reaching past the generated client to build HTTP requests directly.
+ */
+export declare class CatalogClientError extends Error {
+    readonly code: number;
+    readonly data: unknown;
+    readonly operationName: string;
+    constructor(operationName: string, error: JsonRpcErrorObject);
+    /** True when the server did not recognize the operation (version skew). */
+    get isUnknownOperation(): boolean;
+}
+type CatalogOperationTypes = Record<string, {
+    readonly input: unknown;
+    readonly output: unknown;
+}>;
+export type CatalogWeftClient<Operations extends CatalogOperationTypes> = {
+    readonly [Name in keyof Operations]: (input: Operations[Name]['input']) => Promise<Operations[Name]['output']>;
+};
+export type WeftClientConnection = ConnectionOptions;
+/**
+ * Transport seam for the catalog client. Every generated operation method
+ * resolves to one call into a `CatalogTransport`, which carries the operation
+ * name plus its validated input and returns the operation's result.
+ *
+ * The HTTP transport ({@link httpJsonRpcTransport}) speaks JSON-RPC over the
+ * wire; an in-process transport routes the same calls straight into a local
+ * `Engine` so the embedded `LocalClient` and the remote CLI/`HttpClient` share
+ * one generated surface instead of drifting apart.
+ */
+export type CatalogTransport = (operationName: string, input: unknown) => Promise<unknown>;
+/**
+ * Build a catalog client from a list of operation names and a transport. Each
+ * name becomes a method that forwards its input through the transport, so the
+ * full catalog is reachable without hand-authoring a method per operation.
+ */
+export declare function createCatalogWeftClient<Operations extends CatalogOperationTypes>(operationNames: readonly (keyof Operations & string)[], transport: CatalogTransport): CatalogWeftClient<Operations>;
+/**
+ * Transport that dispatches catalog operations as JSON-RPC requests to a
+ * remote Weft server, resolving the connection (server URL + token) per call.
+ */
+export declare function httpJsonRpcTransport(connectionOptions?: WeftClientConnection): CatalogTransport;
+export {};

package/dist/cli/operation-client-runtime.js

@@ -0,0 +1,33 @@
+import { sendJsonRpcRequest } from "./json-rpc-client.js";
+const METHOD_NOT_FOUND_CODE = -32601;
+
+export class CatalogClientError extends Error {
+  code;
+  data;
+  operationName;
+  constructor(operationName, error) {
+    super(error.message);
+    this.name = "CatalogClientError";
+    this.code = error.code;
+    this.data = error.data;
+    this.operationName = operationName;
+  }
+  get isUnknownOperation() {
+    return this.code === METHOD_NOT_FOUND_CODE;
+  }
+}
+export function createCatalogWeftClient(operationNames, transport) {
+  const methods = {};
+  for (const operationName of operationNames)
+    methods[operationName] = (input) => transport(operationName, input);
+  return methods;
+}
+export function httpJsonRpcTransport(connectionOptions = {}) {
+  return (operationName, input) => callJsonRpc(operationName, input, connectionOptions);
+}
+async function callJsonRpc(operationName, input, connectionOptions) {
+  const result = await sendJsonRpcRequest(connectionOptions, operationName, input, "weft-client");
+  if (!result.ok)
+    throw new CatalogClientError(operationName, result.error);
+  return result.result;
+}

package/dist/cli/output.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Shared output helpers for the hand-authored, server-facing CLI commands.
+ *
+ * Centralizes color detection (TTY + `NO_COLOR`/`FORCE_COLOR`), human-friendly
+ * duration and timestamp rendering, NDJSON serialization, and destructive-action
+ * confirmation. Every noun-verb command consumes these helpers so the DX
+ * conventions (table on a TTY, NDJSON under `--json`, prompts before destructive
+ * operations) stay consistent across the surface.
+ *
+ * @module cli/output
+ */
+/** Returns true when ANSI color should be emitted for the given stream. */
+export declare function supportsColor(stream?: {
+    isTTY?: boolean;
+} | undefined): boolean;
+/** ANSI color helpers gated by {@link supportsColor}. */
+export declare const color: {
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    red: (text: string) => string;
+    cyan: (text: string) => string;
+    dim: (text: string) => string;
+    bold: (text: string) => string;
+};
+/**
+ * Serialize an array of values as NDJSON: one compact JSON object per line.
+ * Entries that `JSON.stringify` cannot encode (e.g. `undefined`, functions)
+ * are skipped so the output is always valid NDJSON.
+ */
+export declare function ndjson(values: readonly unknown[]): string;
+/**
+ * Pretty-print a single value as indented JSON for non-list `--json` output.
+ * Returns `'null'` when `JSON.stringify` yields `undefined` (e.g. for void
+ * results) so the contract of returning a valid JSON string is always upheld.
+ */
+export declare function prettyJson(value: unknown): string;
+/** Render a Unix-millisecond timestamp as an ISO string, or `-` when absent. */
+export declare function formatTimestamp(value: unknown): string;
+/**
+ * Render a millisecond duration as a compact human string (e.g. `1.5s`, `2m 3s`,
+ * `1h 4m`). Sub-second durations render in milliseconds.
+ */
+export declare function formatDuration(milliseconds: number): string;
+/**
+ * Truncate a string to fit a terminal column width, appending an ellipsis when
+ * the value is clipped. A non-positive or non-finite width returns the value
+ * unchanged so non-TTY output is never lossy.
+ */
+export declare function truncateToWidth(value: string, width: number): string;
+/**
+ * Confirmation gate for destructive operations.
+ *
+ * - `assumeYes` (the `--yes`/`-y` flag) bypasses the prompt entirely and returns `'confirmed'`.
+ * - On a non-interactive stdin without `--yes`, returns `'non-interactive'` so the caller
+ *   can exit 1 with a clear message rather than hanging on a prompt.
+ * - On a TTY, prints `prompt` and reads a line; defaults to No unless the reply
+ *   starts with `y`/`Y`. Returns `'confirmed'` or `'denied'` accordingly.
+ */
+export declare function confirmDestructive(options: {
+    readonly prompt: string;
+    readonly assumeYes: boolean;
+    readonly isTty?: boolean;
+    readonly readLine?: () => Promise<string>;
+}): Promise<'confirmed' | 'denied' | 'non-interactive'>;
+/** Extract a human-readable message from an unknown error value. */
+export declare function messageOf(error: unknown): string;

package/dist/cli/output.js

@@ -0,0 +1,83 @@
+export function supportsColor(stream = process.stdout) {
+  if (process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "")
+    return !1;
+  const forceColor = process.env.FORCE_COLOR;
+  if (forceColor !== void 0 && forceColor !== "" && forceColor !== "0")
+    return !0;
+  return stream?.isTTY === !0;
+}
+export const color = {
+  green: (text) => supportsColor() ? `\x1B[32m${text}\x1B[0m` : text,
+  yellow: (text) => supportsColor() ? `\x1B[33m${text}\x1B[0m` : text,
+  red: (text) => supportsColor() ? `\x1B[31m${text}\x1B[0m` : text,
+  cyan: (text) => supportsColor() ? `\x1B[36m${text}\x1B[0m` : text,
+  dim: (text) => supportsColor() ? `\x1B[2m${text}\x1B[0m` : text,
+  bold: (text) => supportsColor() ? `\x1B[1m${text}\x1B[0m` : text
+};
+export function ndjson(values) {
+  return values.map((value) => JSON.stringify(value)).filter((line) => line !== void 0).join(`
+`);
+}
+export function prettyJson(value) {
+  return JSON.stringify(value, null, 2) ?? "null";
+}
+export function formatTimestamp(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return "-";
+  return new Date(value).toISOString();
+}
+export function formatDuration(milliseconds) {
+  if (!Number.isFinite(milliseconds) || milliseconds < 0)
+    return "-";
+  const wholeMilliseconds = Math.floor(milliseconds);
+  if (wholeMilliseconds < 1000)
+    return `${wholeMilliseconds}ms`;
+  const totalSeconds = milliseconds / 1000, totalWholeSeconds = Math.floor(totalSeconds);
+  if (totalWholeSeconds < 60) {
+    if (totalWholeSeconds < 10)
+      return `${Math.min(totalSeconds, totalWholeSeconds + 0.9).toFixed(1)}s`;
+    return `${totalWholeSeconds}s`;
+  }
+  const totalMinutes = Math.floor(totalWholeSeconds / 60), seconds = totalWholeSeconds - totalMinutes * 60;
+  if (totalMinutes < 60)
+    return `${totalMinutes}m ${seconds}s`;
+  const hours = Math.floor(totalMinutes / 60), minutes = totalMinutes - hours * 60;
+  return `${hours}h ${minutes}m`;
+}
+export function truncateToWidth(value, width) {
+  if (!Number.isFinite(width) || width <= 0 || value.length <= width)
+    return value;
+  if (width <= 1)
+    return value.slice(0, width);
+  return `${value.slice(0, width - 1)}\u2026`;
+}
+export async function confirmDestructive(options) {
+  if (options.assumeYes)
+    return "confirmed";
+  if (!(options.isTty ?? Boolean(process.stdin.isTTY)))
+    return "non-interactive";
+  const readLine = options.readLine ?? defaultReadLine;
+  process.stdout.write(`${options.prompt} [y/N] `);
+  return (await readLine()).trim().toLowerCase().startsWith("y") ? "confirmed" : "denied";
+}
+async function defaultReadLine() {
+  const reader = Bun.stdin.stream().getReader(), decoder = new TextDecoder;
+  let accumulated = "";
+  try {
+    for (;; ) {
+      const { value, done } = await reader.read();
+      if (done || value === void 0)
+        return accumulated;
+      accumulated += decoder.decode(value, { stream: !0 });
+      const newlineIndex = accumulated.indexOf(`
+`);
+      if (newlineIndex !== -1)
+        return accumulated.slice(0, newlineIndex);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+export function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}

package/dist/cli/parse-arguments.d.ts

@@ -0,0 +1,3 @@
+import type { CliCommand } from './types.ts';
+/** Parses raw CLI arguments into a command object for the runner. */
+export declare function parseCliArguments(args: string[]): CliCommand;

package/dist/cli/parse-arguments.js

@@ -0,0 +1,214 @@
+import { parseArgs } from "node:util";
+import { parseApiArguments } from "./api-arguments.js";
+import { parseCodegenArguments } from "./codegen-arguments.js";
+import { formatUnknownCommandError } from "./command-suggestions.js";
+import {
+  parseCompletionsArguments,
+  parseServerArguments,
+  parseTailArguments,
+  parseWorkflowArguments
+} from "./noun-verb-arguments.js";
+import { parseScheduleArguments } from "./parse-schedule-arguments.js";
+import { parseStorageBackend } from "./storage-backend-arguments.js";
+import { CLI_FLAG_VALUE_OPTIONS } from "./subcommand-detection.js";
+const KNOWN_SUBCOMMANDS = new Set([
+  "serve",
+  "doctor",
+  "version:check",
+  "validate",
+  "conformance",
+  "timeline",
+  "schedule",
+  "codegen",
+  "api",
+  "server",
+  "workflow",
+  "tail",
+  "completions"
+]), SUBCOMMAND_PARSERS = {
+  serve: parseServeArguments,
+  doctor: parseDoctorArguments,
+  "version:check": parseVersionCheckArguments,
+  validate: parseValidateArguments,
+  conformance: parseConformanceArguments,
+  timeline: parseTimelineArguments,
+  schedule: parseScheduleArguments,
+  codegen: parseCodegenArguments,
+  api: parseApiArguments,
+  server: parseServerArguments,
+  workflow: parseWorkflowArguments,
+  tail: parseTailArguments,
+  completions: parseCompletionsArguments
+}, KNOWN_SUBCOMMAND_LIST = [...KNOWN_SUBCOMMANDS];
+function isLeadingVersionRequest(args) {
+  const leading = args[0];
+  return leading === "--version" || leading === "-v" || leading === "version";
+}
+function findSubcommand(args) {
+  for (let index = 0;index < args.length; index++) {
+    const arg = args[index];
+    if (arg.startsWith("-")) {
+      if (CLI_FLAG_VALUE_OPTIONS.has(arg))
+        index++;
+      continue;
+    }
+    if (KNOWN_SUBCOMMANDS.has(arg))
+      return { subcommand: arg, subcommandIndex: index };
+    throw Error(formatUnknownCommandError(arg, KNOWN_SUBCOMMAND_LIST));
+  }
+  return { subcommandIndex: -1 };
+}
+function removeSubcommand(args, subcommandIndex) {
+  return subcommandIndex >= 0 ? [...args.slice(0, subcommandIndex), ...args.slice(subcommandIndex + 1)] : args;
+}
+export function parseCliArguments(args) {
+  if (isLeadingVersionRequest(args))
+    return { command: "version" };
+  const { subcommand, subcommandIndex } = findSubcommand(args), remainingArgs = removeSubcommand(args, subcommandIndex), parser = SUBCOMMAND_PARSERS[subcommand ?? ""];
+  return parser ? parser(remainingArgs) : parseServeArguments(remainingArgs);
+}
+function parseServeArguments(args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      port: { type: "string", short: "p", default: "7233" },
+      database: { type: "string", short: "d", default: "./weft.db" },
+      storage: { type: "string", short: "s", default: "sqlite" },
+      help: { type: "boolean", short: "h", default: !1 },
+      workflows: { type: "string", short: "w" }
+    },
+    strict: !0,
+    allowPositionals: !1,
+    allowNegative: !0
+  });
+  if (values.workflows === "")
+    throw Error("--workflows must be a non-empty path");
+  return {
+    command: "serve",
+    port: values.port ?? "7233",
+    database: values.database ?? "./weft.db",
+    storage: parseStorageBackend(values.storage),
+    help: values.help ?? !1,
+    ...values.workflows ? { workflows: values.workflows } : {}
+  };
+}
+function parseDoctorArguments(args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      database: { type: "string", short: "d", default: "./weft.db" },
+      help: { type: "boolean", short: "h", default: !1 },
+      json: { type: "boolean", short: "j", default: !1 }
+    },
+    strict: !0,
+    allowPositionals: !1
+  });
+  return {
+    command: "doctor",
+    database: values.database ?? "./weft.db",
+    help: values.help ?? !1,
+    json: values.json ?? !1
+  };
+}
+function parseVersionCheckArguments(args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      database: { type: "string", short: "d", default: "./weft.db" },
+      workflows: { type: "string", short: "w", default: "" },
+      help: { type: "boolean", short: "h", default: !1 },
+      json: { type: "boolean", short: "j", default: !1 }
+    },
+    strict: !0,
+    allowPositionals: !1
+  });
+  return {
+    command: "version:check",
+    database: values.database ?? "./weft.db",
+    workflows: values.workflows ?? "",
+    help: values.help ?? !1,
+    json: values.json ?? !1
+  };
+}
+function parseValidateArguments(args) {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      help: { type: "boolean", short: "h", default: !1 },
+      json: { type: "boolean", short: "j", default: !1 }
+    },
+    strict: !0,
+    allowPositionals: !0
+  });
+  return {
+    command: "validate",
+    entryPaths: positionals,
+    help: values.help ?? !1,
+    json: values.json ?? !1
+  };
+}
+function parseConformanceTimeout(value) {
+  const timeoutMs = Number(value ?? "15000");
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0)
+    throw Error("--timeout must be a positive integer number of milliseconds");
+  return timeoutMs;
+}
+function parseConformanceArguments(args) {
+  const separatorIndex = args.indexOf("--"), optionArgs = separatorIndex === -1 ? args : args.slice(0, separatorIndex), workerCommand = separatorIndex === -1 ? [] : args.slice(separatorIndex + 1), { values } = parseArgs({
+    args: optionArgs,
+    options: {
+      timeout: { type: "string", default: "15000" },
+      help: { type: "boolean", short: "h", default: !1 },
+      json: { type: "boolean", short: "j", default: !1 }
+    },
+    strict: !0,
+    allowPositionals: !1
+  });
+  return {
+    command: "conformance",
+    timeoutMs: parseConformanceTimeout(values.timeout),
+    help: values.help ?? !1,
+    json: values.json ?? !1,
+    workerCommand
+  };
+}
+function parseTimelineStep(value, flagName) {
+  const step = Number(value);
+  if (!Number.isSafeInteger(step) || step < 0)
+    throw Error(`${flagName} must be a non-negative integer`);
+  return step;
+}
+function parseOptionalTimelineStep(value) {
+  return value !== void 0 ? parseTimelineStep(value, "--step") : void 0;
+}
+function parseTimelineDiff(enabled, positionals) {
+  if (!enabled)
+    return;
+  const fromStep = positionals[1], toStep = positionals[2];
+  if (fromStep === void 0 || toStep === void 0)
+    throw Error("--diff requires two step numbers");
+  return [parseTimelineStep(fromStep, "--diff"), parseTimelineStep(toStep, "--diff")];
+}
+function parseTimelineArguments(args) {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      database: { type: "string", short: "d", default: "./weft.db" },
+      step: { type: "string" },
+      diff: { type: "boolean", default: !1 },
+      help: { type: "boolean", short: "h", default: !1 }
+    },
+    strict: !0,
+    allowPositionals: !0
+  }), step = parseOptionalTimelineStep(values.step), diff = parseTimelineDiff(values.diff, positionals);
+  if (step !== void 0 && diff !== void 0)
+    throw Error("--step and --diff cannot be used together");
+  return {
+    command: "timeline",
+    database: values.database ?? "./weft.db",
+    workflowId: positionals[0] ?? "",
+    ...step !== void 0 ? { step } : {},
+    ...diff !== void 0 ? { diff } : {},
+    help: values.help ?? !1
+  };
+}

package/dist/cli/parse-schedule-arguments.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CLI parsing for the `weft schedule` subcommand and its actions
+ * (`list`, `create`, `pause`, `resume`, `cancel`).
+ *
+ * @module cli/parse-schedule-arguments
+ */
+import type { CliCommand } from './types.ts';
+/** Parse `weft schedule <action> [...]` into a {@link CliCommand}. */
+export declare function parseScheduleArguments(args: string[]): CliCommand;

package/dist/cli/parse-schedule-arguments.js

@@ -0,0 +1,132 @@
+import { parseArgs } from "node:util";
+import { parsePersistentStorageBackend } from "./storage-backend-arguments.js";
+const SCHEDULE_ACTIONS = new Set(["list", "create", "pause", "resume", "cancel"]), VALID_SCHEDULE_OVERLAP_POLICIES = new Set(["skip", "queue", "cancel-running", "allow"]);
+function parseScheduleCliValues(args) {
+  return parseArgs({
+    args,
+    options: {
+      database: { type: "string", short: "d", default: "./weft.db" },
+      storage: { type: "string", short: "s", default: "sqlite" },
+      workflows: { type: "string", short: "w", default: "" },
+      every: { type: "string" },
+      input: { type: "string", default: "null" },
+      id: { type: "string" },
+      overlap: { type: "string" },
+      backfill: { type: "boolean", default: !1 },
+      help: { type: "boolean", short: "h", default: !1 },
+      json: { type: "boolean", short: "j", default: !1 }
+    },
+    strict: !0,
+    allowPositionals: !0
+  });
+}
+function isScheduleOverlapPolicy(value) {
+  return VALID_SCHEDULE_OVERLAP_POLICIES.has(value);
+}
+function parseScheduleOverlapPolicy(value) {
+  if (value === void 0)
+    return;
+  if (!isScheduleOverlapPolicy(value))
+    throw Error(`Invalid overlap policy '${value}'. Must be one of: skip, queue, cancel-running, allow`);
+  return value;
+}
+function buildScheduleListCommand(values) {
+  return {
+    command: "schedule",
+    action: "list",
+    database: values.database ?? "./weft.db",
+    storage: parsePersistentStorageBackend(values.storage),
+    help: values.help ?? !1,
+    json: values.json ?? !1
+  };
+}
+function buildScheduleHelpCommand(values) {
+  return {
+    command: "schedule",
+    action: "list",
+    database: values.database ?? "./weft.db",
+    storage: "sqlite",
+    help: !0,
+    json: values.json ?? !1
+  };
+}
+function defaultString(value, fallback) {
+  return value ?? fallback;
+}
+function defaultBoolean(value) {
+  return value ?? !1;
+}
+function formatScheduleActionList() {
+  return [...SCHEDULE_ACTIONS].join(", ");
+}
+function assertExactSchedulePositionals(action, positionals, count, usage) {
+  if (positionals.length === count)
+    return;
+  throw Error(`schedule ${action} expects exactly ${count} ${count === 1 ? "positional argument" : "positional arguments"}: ${usage}`);
+}
+function isScheduleAction(value) {
+  return SCHEDULE_ACTIONS.has(value);
+}
+function requireScheduleAction(positionals) {
+  const action = positionals[0];
+  if (action === void 0)
+    throw Error(`Missing schedule action. Expected one of: ${formatScheduleActionList()}`);
+  if (!isScheduleAction(action))
+    throw Error(`Unknown schedule action "${action}". Expected one of: ${formatScheduleActionList()}`);
+  return action;
+}
+function buildScheduleCreateOptionalFields(values) {
+  const overlap = parseScheduleOverlapPolicy(values.overlap);
+  return {
+    ...values.id !== void 0 ? { id: values.id } : {},
+    ...overlap !== void 0 ? { overlap } : {}
+  };
+}
+function buildScheduleCreateCommand(values, positionals) {
+  return {
+    command: "schedule",
+    action: "create",
+    database: defaultString(values.database, "./weft.db"),
+    storage: parsePersistentStorageBackend(values.storage),
+    workflows: defaultString(values.workflows, ""),
+    workflowType: defaultString(positionals[0], ""),
+    cronExpression: defaultString(positionals[1], ""),
+    ...values.every !== void 0 ? { every: values.every } : {},
+    input: defaultString(values.input, "null"),
+    ...buildScheduleCreateOptionalFields(values),
+    backfill: defaultBoolean(values.backfill),
+    help: defaultBoolean(values.help),
+    json: defaultBoolean(values.json)
+  };
+}
+function buildScheduleMutationCommand(action, values, positionals) {
+  return {
+    command: "schedule",
+    action,
+    database: values.database ?? "./weft.db",
+    storage: parsePersistentStorageBackend(values.storage),
+    scheduleId: positionals[0] ?? "",
+    help: values.help ?? !1,
+    json: values.json ?? !1
+  };
+}
+export function parseScheduleArguments(args) {
+  const { values, positionals } = parseScheduleCliValues(args);
+  if (values.help)
+    return buildScheduleHelpCommand(values);
+  const action = requireScheduleAction(positionals), actionPositionals = positionals.slice(1);
+  if (action === "create") {
+    if (values.every !== void 0)
+      assertExactSchedulePositionals(action, actionPositionals, 1, "<workflowType> --every <duration>");
+    else
+      assertExactSchedulePositionals(action, actionPositionals, 2, "<workflowType> <cronExpression>");
+    return buildScheduleCreateCommand(values, actionPositionals);
+  }
+  if (action === "pause" || action === "resume" || action === "cancel") {
+    assertExactSchedulePositionals(action, actionPositionals, 1, "<scheduleId>");
+    return buildScheduleMutationCommand(action, values, actionPositionals);
+  }
+  if (actionPositionals.length > 0)
+    throw Error("schedule list does not accept positional arguments");
+  return buildScheduleListCommand(values);
+}

package/dist/cli/schedule.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOutput, ScheduleCommand } from './types.ts';
+/** Executes schedule listing, creation, pausing, resuming, and cancellation. */
+export declare function executeSchedule(options: ScheduleCommand): Promise<CommandOutput>;