@lostgradient/weft 0.2.0

package/dist/cli/tail.js

@@ -0,0 +1,161 @@
+import { resolveConnection } from "../connection.js";
+import { color, messageOf } from "./output.js";
+function sseEndpoint(server, workflowId) {
+  const endpoint = new URL(server.toString()), basePath = endpoint.pathname.endsWith("/") ? endpoint.pathname : `${endpoint.pathname}/`;
+  endpoint.pathname = `${basePath}v1/workflows/${encodeURIComponent(workflowId)}/sse`.replaceAll(/\/+/g, "/");
+  endpoint.search = "";
+  endpoint.hash = "";
+  return endpoint;
+}
+function parseFieldLine(rawLine) {
+  if (rawLine === "" || rawLine.startsWith(":"))
+    return;
+  const colonIndex = rawLine.indexOf(":"), field = colonIndex === -1 ? rawLine : rawLine.slice(0, colonIndex), valueRaw = colonIndex === -1 ? "" : rawLine.slice(colonIndex + 1);
+  return { field, value: valueRaw.startsWith(" ") ? valueRaw.slice(1) : valueRaw };
+}
+function parseFrame(block) {
+  let id, event = "message";
+  const dataLines = [];
+  for (const rawLine of block.split(`
+`)) {
+    const parsed = parseFieldLine(rawLine);
+    if (parsed === void 0)
+      continue;
+    if (parsed.field === "id")
+      id = parsed.value;
+    else if (parsed.field === "event")
+      event = parsed.value;
+    else if (parsed.field === "data")
+      dataLines.push(parsed.value);
+  }
+  if (id === void 0 && dataLines.length === 0 && event === "message")
+    return;
+  return { ...id === void 0 ? {} : { id }, event, data: dataLines.join(`
+`) };
+}
+function formatEvent(frame, json) {
+  if (json)
+    return JSON.stringify({
+      ...frame.id === void 0 ? {} : { id: frame.id },
+      event: frame.event,
+      data: frame.data
+    });
+  return `${frame.id === void 0 ? "" : `${color.dim(`[${frame.id}]`)} `}${color.cyan(frame.event)}  ${frame.data}`;
+}
+async function connectSse(options) {
+  const fetchImpl = options.fetchImpl ?? fetch, headers = new Headers({ Accept: "text/event-stream" });
+  if (options.token !== void 0 && options.token !== "")
+    headers.set("authorization", `Bearer ${options.token}`);
+  const reportError = options.reportError ?? options.write;
+  let response;
+  try {
+    response = await fetchImpl(options.url, { method: "GET", headers, signal: options.signal });
+  } catch (error) {
+    if (options.signal.aborted)
+      return { kind: "done", exitCode: 0 };
+    reportError(`tail: connection failed: ${messageOf(error)}`);
+    return { kind: "done", exitCode: 2 };
+  }
+  if (!response.ok || response.body === null) {
+    reportError(`tail: server returned status ${response.status}`);
+    return { kind: "done", exitCode: 1 };
+  }
+  return { kind: "stream", body: response.body };
+}
+function drainFrames(buffer, options) {
+  let separatorIndex = buffer.indexOf(`
+
+`);
+  while (separatorIndex !== -1) {
+    const block = buffer.slice(0, separatorIndex);
+    buffer = buffer.slice(separatorIndex + 2);
+    const frame = parseFrame(block);
+    if (frame !== void 0) {
+      if (frame.event === "done")
+        return null;
+      options.write(formatEvent(frame, options.json));
+    }
+    separatorIndex = buffer.indexOf(`
+
+`);
+  }
+  return buffer;
+}
+export async function streamWorkflowEvents(options) {
+  const outcome = await connectSse(options);
+  if (outcome.kind === "done")
+    return outcome.exitCode;
+  const reader = outcome.body.getReader(), decoder = new TextDecoder;
+  let buffer = "";
+  const onAbort = () => void reader.cancel().catch(() => {
+    return;
+  });
+  options.signal.addEventListener("abort", onAbort, { once: !0 });
+  try {
+    for (;; ) {
+      let value;
+      try {
+        const chunk = await reader.read();
+        if (chunk.done)
+          return 0;
+        value = chunk.value;
+      } catch (error) {
+        if (options.signal.aborted)
+          return 0;
+        (options.reportError ?? options.write)(`tail: stream error: ${error instanceof Error ? error.message : String(error)}`);
+        return 2;
+      }
+      if (value === void 0)
+        return 0;
+      buffer += decoder.decode(value, { stream: !0 });
+      const remainder = drainFrames(buffer, options);
+      if (remainder === null)
+        return 0;
+      buffer = remainder;
+    }
+  } finally {
+    options.signal.removeEventListener("abort", onAbort);
+  }
+}
+export async function executeTail(command) {
+  if (command.workflowId === void 0 || command.workflowId === "")
+    return {
+      stdout: "",
+      stderr: "tail: a workflow id is required (system-wide tail is not yet available). Usage: weft tail <workflow-id>",
+      exitCode: 3
+    };
+  const connection = {
+    ...command.server === void 0 ? {} : { server: command.server },
+    ...command.token === void 0 ? {} : { token: command.token },
+    ...command.profile === void 0 ? {} : { profile: command.profile }
+  };
+  let resolved;
+  try {
+    resolved = resolveConnection(connection);
+  } catch (error) {
+    return {
+      stdout: "",
+      stderr: `tail: connection error: ${messageOf(error)}`,
+      exitCode: 2
+    };
+  }
+  const controller = new AbortController, onSigint = () => controller.abort();
+  process.on("SIGINT", onSigint);
+  try {
+    return { stdout: "", exitCode: await streamWorkflowEvents({
+      url: sseEndpoint(resolved.server, command.workflowId),
+      ...resolved.token === void 0 ? {} : { token: resolved.token },
+      signal: controller.signal,
+      write: (line) => {
+        if (!command.quiet)
+          process.stdout.write(`${line}
+`);
+      },
+      reportError: (line) => process.stderr.write(`${line}
+`),
+      json: command.json
+    }) };
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+}

package/dist/cli/timeline.d.ts

@@ -0,0 +1,9 @@
+import type { CommandOutput } from './types.ts';
+export { collectDiffLines } from './utilities.ts';
+/** Executes timeline inspection and replay checkpoint diff commands. */
+export declare function executeTimeline(options: {
+    database: string;
+    workflowId: string;
+    step?: number;
+    diff?: [number, number];
+}): Promise<CommandOutput>;

package/dist/cli/timeline.js

@@ -0,0 +1,78 @@
+import { collectDiffLines, formatValue } from "./utilities.js";
+export { collectDiffLines } from "./utilities.js";
+function formatTimelineLine(entry) {
+  const duration = entry.duration !== void 0 ? `${entry.duration}ms` : "-", output = entry.outputSummary ?? "(pending)";
+  return `Step ${entry.step} | ${entry.operationType} | ${entry.operationLabel} | ${entry.status} | ${duration} | ${output}`;
+}
+function formatReplayDetails(options) {
+  return {
+    stdout: [
+      `Replay step ${options.step} for ${options.workflowId}`,
+      "",
+      `Checkpoint: ${formatValue(options.replay.checkpoint)}`,
+      "",
+      `Accumulated results: ${formatValue(options.replay.accumulatedResults)}`,
+      "",
+      `Events: ${formatValue(options.replay.events)}`
+    ].join(`
+`),
+    exitCode: 0
+  };
+}
+export async function executeTimeline(options) {
+  if (!options.workflowId)
+    return {
+      stdout: "",
+      stderr: "Error: workflowId is required for timeline",
+      exitCode: 1
+    };
+  const { BunSQLiteStorage } = await import("../storage/bun-sql.js"), storage = new BunSQLiteStorage(options.database), { Engine } = await import("../core/engine.js"), engine = new Engine({ storage });
+  try {
+    if (await engine.get(options.workflowId) === null)
+      return {
+        stdout: "",
+        stderr: `Error: workflow "${options.workflowId}" not found`,
+        exitCode: 1
+      };
+    if (options.step !== void 0) {
+      const replay = await engine.replayTo(options.workflowId, options.step);
+      if (replay === null)
+        return {
+          stdout: "",
+          stderr: `Error: replay not found for step ${options.step}`,
+          exitCode: 1
+        };
+      return formatReplayDetails({
+        workflowId: options.workflowId,
+        step: options.step,
+        replay
+      });
+    }
+    if (options.diff !== void 0) {
+      const [fromStep, toStep] = options.diff, fromReplay = await engine.replayTo(options.workflowId, fromStep), toReplay = await engine.replayTo(options.workflowId, toStep);
+      if (fromReplay === null || toReplay === null)
+        return {
+          stdout: "",
+          stderr: `Error: replay not found for diff ${fromStep} -> ${toStep}`,
+          exitCode: 1
+        };
+      const lines = [];
+      collectDiffLines(fromReplay.checkpoint, toReplay.checkpoint, "checkpoint", lines);
+      collectDiffLines(fromReplay.accumulatedResults, toReplay.accumulatedResults, "accumulatedResults", lines);
+      return {
+        stdout: [`Diff ${fromStep} -> ${toStep} for ${options.workflowId}`, ...lines].join(`
+`),
+        exitCode: 0
+      };
+    }
+    const timeline = await engine.getTimeline(options.workflowId);
+    return {
+      stdout: timeline.length === 0 ? `No timeline entries found for workflow "${options.workflowId}".` : timeline.map(formatTimelineLine).join(`
+`),
+      exitCode: 0
+    };
+  } finally {
+    await engine[Symbol.asyncDispose]();
+    storage[Symbol.dispose]();
+  }
+}

package/dist/cli/types.d.ts

@@ -0,0 +1,224 @@
+import type { ScheduleOverlapPolicy } from '../core/types.ts';
+/** Supported storage backend identifiers for the `--storage` flag. */
+export type StorageBackend = 'sqlite' | 'lmdb' | 'memory';
+/** Storage backends suitable for commands that must survive process exit. */
+export type PersistentStorageBackend = Exclude<StorageBackend, 'memory'>;
+/** Parsed command variants accepted by the CLI runner. */
+export type CliCommand = {
+    command: 'serve';
+    port: string;
+    database: string;
+    storage: StorageBackend;
+    help: boolean;
+    workflows?: string;
+} | {
+    command: 'version';
+} | {
+    command: 'doctor';
+    database: string;
+    help: boolean;
+    json: boolean;
+} | {
+    command: 'version:check';
+    database: string;
+    workflows: string;
+    help: boolean;
+    json: boolean;
+} | {
+    command: 'validate';
+    entryPaths: string[];
+    help: boolean;
+    json: boolean;
+} | {
+    command: 'codegen';
+    server?: string;
+    from?: string;
+    token?: string;
+    out: string;
+    timeoutMs: number;
+    help: boolean;
+    json: boolean;
+} | {
+    command: 'api';
+    operationName?: string;
+    server?: string;
+    token?: string;
+    profile?: string;
+    input?: string;
+    inputFile?: string;
+    list: boolean;
+    describe?: string;
+    yes: boolean;
+    help: boolean;
+    json: boolean;
+} | {
+    command: 'conformance';
+    timeoutMs: number;
+    help: boolean;
+    json: boolean;
+    workerCommand: string[];
+} | {
+    command: 'timeline';
+    database: string;
+    workflowId: string;
+    step?: number;
+    diff?: [number, number];
+    help: boolean;
+} | {
+    command: 'schedule';
+    action: 'list';
+    database: string;
+    storage: PersistentStorageBackend;
+    help: boolean;
+    json: boolean;
+} | {
+    command: 'schedule';
+    action: 'create';
+    database: string;
+    storage: PersistentStorageBackend;
+    workflows: string;
+    workflowType: string;
+    cronExpression: string;
+    every?: string;
+    input: string;
+    id?: string;
+    overlap?: ScheduleOverlapPolicy;
+    backfill: boolean;
+    help: boolean;
+    json: boolean;
+} | {
+    command: 'schedule';
+    action: 'pause' | 'resume' | 'cancel';
+    database: string;
+    storage: PersistentStorageBackend;
+    scheduleId: string;
+    help: boolean;
+    json: boolean;
+} | {
+    command: 'server';
+    action: 'health' | 'info';
+    server?: string;
+    token?: string;
+    profile?: string;
+    wait: boolean;
+    waitTimeoutMs: number;
+    help: boolean;
+    json: boolean;
+    quiet: boolean;
+} | {
+    command: 'workflow';
+    action: 'ls';
+    server?: string;
+    token?: string;
+    profile?: string;
+    type?: string;
+    status?: string;
+    limit?: number;
+    help: boolean;
+    json: boolean;
+    quiet: boolean;
+} | {
+    command: 'workflow';
+    action: 'get' | 'events';
+    server?: string;
+    token?: string;
+    profile?: string;
+    workflowId: string;
+    help: boolean;
+    json: boolean;
+    quiet: boolean;
+} | {
+    command: 'workflow';
+    action: 'start';
+    server?: string;
+    token?: string;
+    profile?: string;
+    workflowType: string;
+    input?: string;
+    inputFile?: string;
+    id?: string;
+    help: boolean;
+    json: boolean;
+    quiet: boolean;
+} | {
+    command: 'workflow';
+    action: 'cancel';
+    server?: string;
+    token?: string;
+    profile?: string;
+    workflowId: string;
+    yes: boolean;
+    dryRun: boolean;
+    help: boolean;
+    json: boolean;
+    quiet: boolean;
+} | {
+    command: 'workflow';
+    action: 'signal';
+    server?: string;
+    token?: string;
+    profile?: string;
+    workflowId: string;
+    signalName: string;
+    input?: string;
+    inputFile?: string;
+    help: boolean;
+    json: boolean;
+    quiet: boolean;
+} | {
+    command: 'tail';
+    server?: string;
+    token?: string;
+    profile?: string;
+    workflowId?: string;
+    help: boolean;
+    json: boolean;
+    quiet: boolean;
+} | {
+    command: 'completions';
+    action: 'install' | 'generate';
+    shell: CompletionShell;
+    help: boolean;
+};
+/** Supported shells for `weft completions`. */
+export type CompletionShell = 'zsh' | 'bash' | 'fish';
+/** Parsed `weft server` command variants. */
+export type ServerCommand = Extract<CliCommand, {
+    command: 'server';
+}>;
+/** Parsed `weft workflow` command variants. */
+export type WorkflowCommand = Extract<CliCommand, {
+    command: 'workflow';
+}>;
+/** Parsed `weft tail` command. */
+export type TailCommand = Extract<CliCommand, {
+    command: 'tail';
+}>;
+/** Parsed `weft completions` command. */
+export type CompletionsCommand = Extract<CliCommand, {
+    command: 'completions';
+}>;
+/** Parsed schedule command variants. */
+export type ScheduleCommand = Extract<CliCommand, {
+    command: 'schedule';
+}>;
+/** Supported schedule subcommand names. */
+export type ScheduleAction = ScheduleCommand['action'];
+/** Parsed `weft schedule list` command. */
+export type ScheduleListCommand = Extract<ScheduleCommand, {
+    action: 'list';
+}>;
+/** Parsed `weft schedule create` command. */
+export type ScheduleCreateCommand = Extract<ScheduleCommand, {
+    action: 'create';
+}>;
+/** Parsed schedule commands that mutate an existing schedule. */
+export type ScheduleMutationCommand = Extract<ScheduleCommand, {
+    action: 'pause' | 'resume' | 'cancel';
+}>;
+/** Result returned by command executors before the process writes output. */
+export interface CommandOutput {
+    stdout: string;
+    exitCode: number;
+    stderr?: string;
+}

package/dist/cli/utilities.d.ts

@@ -0,0 +1,9 @@
+/** Splits a glob entry path into the directory to scan and the pattern to match. */
+export declare function splitGlobPattern(entryPath: string): {
+    scanRoot: string;
+    pattern: string;
+};
+export declare function expandGlobEntryPaths(entryPaths: string[]): Promise<string[]>;
+export declare function formatValue(value: unknown): string;
+/** Recursively records changed paths between two checkpoint-like values. */
+export declare function collectDiffLines(beforeValue: unknown, afterValue: unknown, path: string, lines: string[]): void;

package/dist/cli/utilities.js

@@ -0,0 +1,120 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { isRecord, safeDebugStringify } from "../core/debug-output.js";
+function isGlobPattern(value) {
+  return value.includes("*") || value.includes("?") || value.includes("[");
+}
+function normalizeGlobPatternPath(entryPath) {
+  return entryPath.replaceAll("\\", "/");
+}
+function isMissingDirectoryError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function globPatternIncludesTestFiles(scanRoot, pattern) {
+  const testSegmentRegex = /(?:^|[./{,])(?:test|tests|spec|specs)(?:[.}/,]|$)/;
+  if (testSegmentRegex.test(normalizeGlobPatternPath(pattern)))
+    return !0;
+  const lastScanRootSegment = normalizeGlobPatternPath(scanRoot).split("/").pop() ?? "";
+  return testSegmentRegex.test(lastScanRootSegment);
+}
+function shouldIgnoreExpandedGlobPath(entryPath, ignoreTestFiles) {
+  const normalizedEntryPath = normalizeGlobPatternPath(entryPath);
+  if (normalizedEntryPath.split("/").includes("node_modules"))
+    return !0;
+  return ignoreTestFiles && (/\.test\.[cm]?tsx?$/.test(normalizedEntryPath) || /\.spec\.[cm]?tsx?$/.test(normalizedEntryPath));
+}
+export function splitGlobPattern(entryPath) {
+  const normalizedEntryPath = normalizeGlobPatternPath(entryPath), firstGlobIndex = Array.from(normalizedEntryPath).findIndex((character) => ["*", "?", "["].includes(character));
+  if (firstGlobIndex === -1)
+    return { scanRoot: ".", pattern: normalizedEntryPath };
+  const separatorIndex = normalizedEntryPath.lastIndexOf("/", firstGlobIndex);
+  if (separatorIndex === -1)
+    return { scanRoot: ".", pattern: normalizedEntryPath };
+  const scanRootCandidate = normalizedEntryPath.slice(0, separatorIndex), scanRoot = scanRootCandidate === "" ? "/" : /^[A-Za-z]:\//.test(normalizedEntryPath) && scanRootCandidate === normalizedEntryPath.slice(0, 2) ? `${scanRootCandidate}/` : scanRootCandidate, pattern = normalizedEntryPath.slice(separatorIndex + 1);
+  return { scanRoot, pattern };
+}
+export async function expandGlobEntryPaths(entryPaths) {
+  const expandedEntryPaths = [];
+  for (const entryPath of entryPaths) {
+    if (!isGlobPattern(entryPath)) {
+      expandedEntryPaths.push(entryPath);
+      continue;
+    }
+    const { scanRoot, pattern } = splitGlobPattern(entryPath), { matchedPaths, ignoredMatchCount } = await scanGlobMatches(scanRoot, pattern, {
+      ignoreTestFiles: !globPatternIncludesTestFiles(scanRoot, pattern),
+      recurseIntoSubdirectories: globPatternMayMatchNestedPath(pattern)
+    }), matches = matchedPaths.map((match) => join(scanRoot, match)).toSorted();
+    if (matches.length > 0)
+      expandedEntryPaths.push(...matches);
+    else if (ignoredMatchCount === 0)
+      expandedEntryPaths.push(entryPath);
+  }
+  return Array.from(new Set(expandedEntryPaths));
+}
+async function scanGlobMatches(scanRoot, pattern, options) {
+  const glob = new Bun.Glob(pattern), matchedPaths = [], scanState = { ignoredMatchCount: 0 };
+  await walkGlobScanRoot(scanRoot, "", glob, matchedPaths, scanState, options);
+  return { ignoredMatchCount: scanState.ignoredMatchCount, matchedPaths };
+}
+async function walkGlobScanRoot(absoluteDirectory, relativeDirectory, glob, matchedPaths, scanState, options) {
+  let directoryEntries;
+  try {
+    directoryEntries = await readdir(absoluteDirectory, { withFileTypes: !0 });
+  } catch (error) {
+    if (isMissingDirectoryError(error))
+      return;
+    throw error;
+  }
+  for (const directoryEntry of directoryEntries) {
+    const relativePath = relativeDirectory ? `${relativeDirectory}/${directoryEntry.name}` : directoryEntry.name;
+    if (handleGlobFileEntry(directoryEntry, relativePath, glob, matchedPaths, scanState, options))
+      continue;
+    if (shouldIgnoreExpandedGlobPath(relativePath, options.ignoreTestFiles))
+      continue;
+    if (directoryEntry.isDirectory()) {
+      if (!options.recurseIntoSubdirectories)
+        continue;
+      await walkGlobScanRoot(join(absoluteDirectory, directoryEntry.name), relativePath, glob, matchedPaths, scanState, options);
+    }
+  }
+}
+function handleGlobFileEntry(directoryEntry, relativePath, glob, matchedPaths, scanState, options) {
+  if (!directoryEntry.isFile() || !glob.match(relativePath))
+    return !1;
+  if (shouldIgnoreExpandedGlobPath(relativePath, options.ignoreTestFiles))
+    scanState.ignoredMatchCount += 1;
+  else
+    matchedPaths.push(relativePath);
+  return !0;
+}
+function globPatternMayMatchNestedPath(pattern) {
+  return pattern.includes("/") || pattern.includes("**");
+}
+export function formatValue(value) {
+  return safeDebugStringify(value, 2);
+}
+function isPlainObjectRecord(value) {
+  if (!isRecord(value))
+    return !1;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+export function collectDiffLines(beforeValue, afterValue, path, lines) {
+  if (Object.is(beforeValue, afterValue))
+    return;
+  if (Array.isArray(beforeValue) && Array.isArray(afterValue)) {
+    const length = Math.max(beforeValue.length, afterValue.length);
+    for (let index = 0;index < length; index++)
+      collectDiffLines(beforeValue[index], afterValue[index], `${path}[${index}]`, lines);
+    return;
+  }
+  if (isPlainObjectRecord(beforeValue) && isPlainObjectRecord(afterValue)) {
+    const keys = new Set([...Object.keys(beforeValue), ...Object.keys(afterValue)]);
+    for (const key of [...keys].toSorted()) {
+      const childPath = path ? `${path}.${key}` : key;
+      collectDiffLines(beforeValue[key], afterValue[key], childPath, lines);
+    }
+    return;
+  }
+  lines.push(`${path}: ${formatValue(beforeValue)} -> ${formatValue(afterValue)}`);
+}

package/dist/cli/validate.d.ts

@@ -0,0 +1,6 @@
+import type { CommandOutput } from './types.ts';
+/** Validates workflow registration modules and reports load or design-time errors. */
+export declare function executeValidate(options: {
+    entryPaths: string[];
+    json: boolean;
+}): Promise<CommandOutput>;

package/dist/cli/validate.js

@@ -0,0 +1,70 @@
+import { expandGlobEntryPaths } from "./utilities.js";
+async function expandValidateEntryPaths(entryPaths) {
+  return expandGlobEntryPaths(entryPaths);
+}
+async function processValidateEntry(entryPath, loadRegistrationsFromModule, validateRegistrations) {
+  try {
+    const loaded = await loadRegistrationsFromModule(entryPath), report = validateRegistrations(loaded.registrations, loaded.activities);
+    return { entryPath, report };
+  } catch (error) {
+    return {
+      entryPath,
+      loadError: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function collectValidationEntries(entryPaths, loadRegistrationsFromModule, validateRegistrations) {
+  const entries = [];
+  let hasLoadErrors = !1, hasValidationErrors = !1;
+  for (const entryPath of entryPaths) {
+    const entry = await processValidateEntry(entryPath, loadRegistrationsFromModule, validateRegistrations);
+    entries.push(entry);
+    if ("loadError" in entry)
+      hasLoadErrors = !0;
+    else if (!entry.report.valid)
+      hasValidationErrors = !0;
+  }
+  return { entries, hasLoadErrors, hasValidationErrors };
+}
+function formatValidationJson(summary) {
+  const entries = summary.entries.map((entry) => {
+    if ("loadError" in entry)
+      return {
+        entryPath: entry.entryPath,
+        loadError: entry.loadError
+      };
+    return {
+      entryPath: entry.entryPath,
+      ...entry.report
+    };
+  });
+  return JSON.stringify({
+    entries,
+    valid: !summary.hasLoadErrors && !summary.hasValidationErrors,
+    hasLoadErrors: summary.hasLoadErrors,
+    hasValidationErrors: summary.hasValidationErrors
+  }, null, 2);
+}
+function formatValidationLoadError(entry) {
+  return `Error: could not load entry file '${entry.entryPath}': ${entry.loadError}`;
+}
+export async function executeValidate(options) {
+  if (options.entryPaths.length === 0)
+    return {
+      stdout: "",
+      stderr: "Error: entry file path is required for validate",
+      exitCode: 2
+    };
+  const expandedEntryPaths = await expandValidateEntryPaths(options.entryPaths), { loadRegistrationsFromModule, validateRegistrations, formatValidationReport } = await import("../diagnostics/validate.js"), summary = await collectValidationEntries(expandedEntryPaths, loadRegistrationsFromModule, validateRegistrations), exitCode = summary.hasLoadErrors ? 2 : summary.hasValidationErrors ? 1 : 0;
+  if (options.json)
+    return { stdout: formatValidationJson(summary), exitCode };
+  const stdout = summary.entries.filter((entry) => ("report" in entry)).map((entry) => formatValidationReport(entry.report, entry.entryPath)).join(`
+
+`), stderr = summary.entries.filter((entry) => ("loadError" in entry)).map(formatValidationLoadError).join(`
+`);
+  return {
+    stdout,
+    ...stderr ? { stderr } : {},
+    exitCode
+  };
+}

package/dist/cli/version-check.d.ts

@@ -0,0 +1,7 @@
+import type { CommandOutput } from './types.ts';
+/** Checks stored workflow history against the current workflow registrations. */
+export declare function executeVersionCheck(options: {
+    database: string;
+    workflows: string;
+    json: boolean;
+}): Promise<CommandOutput>;