@voltro/plugin-ai-flows 0.1.0

package/dist/cadence-Bt6dPelT.js

@@ -0,0 +1,40 @@
+//#region src/cadence.ts
+var e = (e) => (e.getDay() + 6) % 7, t = (e) => Math.ceil(e.getDate() / 7), n = (e) => {
+	let t = new Date(e.getFullYear(), e.getMonth() + 1, 0).getDate();
+	return e.getDate() + 7 > t;
+}, r = (t) => {
+	let n = new Date(t.getFullYear(), t.getMonth(), t.getDate());
+	return n.setDate(n.getDate() - e(t)), n.setHours(0, 0, 0, 0), n;
+}, i = (e, t) => {
+	let n = r(t).getTime() - r(e).getTime();
+	return Math.round(n / (10080 * 60 * 1e3));
+}, a = (r, a) => {
+	let o = r.repeats ?? [];
+	if (o.length === 0) return !1;
+	let s = r.hour ?? 9, c = r.minute ?? 0;
+	if (a.getHours() !== s || a.getMinutes() !== c) return !1;
+	let l = e(a);
+	if (!o.includes(l)) return !1;
+	if ((r.frequency ?? "weekly") === "monthly") {
+		let e = r.weekOfMonth;
+		return e === void 0 ? !0 : e === "last" ? n(a) : t(a) === e;
+	}
+	let u = r.intervalWeeks ?? 1;
+	if (u <= 1 || !r.anchorDate) return !0;
+	let d = /* @__PURE__ */ new Date(`${r.anchorDate}T00:00:00`);
+	if (Number.isNaN(d.getTime())) return !0;
+	let f = i(d, a);
+	return f >= 0 && f % u === 0;
+}, o = (e, t, n = 3) => {
+	let r = [];
+	if ((e.repeats ?? []).length === 0) return r;
+	let i = new Date(t);
+	i.setSeconds(0, 0);
+	let o = i.getMinutes() % 15;
+	(o !== 0 || i.getTime() < t.getTime()) && i.setMinutes(i.getMinutes() + (15 - o));
+	let s = t.getTime() + 400 * 24 * 60 * 60 * 1e3;
+	for (; r.length < n && i.getTime() <= s;) a(e, i) && r.push(new Date(i)), i.setMinutes(i.getMinutes() + 15);
+	return r;
+};
+//#endregion
+export { o as n, a as t };

package/dist/errors.d.ts

@@ -0,0 +1,88 @@
+import { Schema } from 'effect';
+
+/** A required brief field was blank at launch. */
+export declare class FlowBriefIncomplete extends FlowBriefIncomplete_base {
+}
+
+declare const FlowBriefIncomplete_base: Schema.TaggedErrorClass<FlowBriefIncomplete, "FlowBriefIncomplete", {
+    readonly _tag: Schema.tag<"FlowBriefIncomplete">;
+} & {
+    missing: Schema.Array$<typeof Schema.String>;
+    message: typeof Schema.String;
+}>;
+
+/** A generation step required a capability the host did not provide (e.g. a
+ *  media modality with no configured generator, or storage for the artifact). */
+export declare class FlowCapabilityMissing extends FlowCapabilityMissing_base {
+}
+
+declare const FlowCapabilityMissing_base: Schema.TaggedErrorClass<FlowCapabilityMissing, "FlowCapabilityMissing", {
+    readonly _tag: Schema.tag<"FlowCapabilityMissing">;
+} & {
+    capability: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+
+/** A step's input still contains an unresolved `{{ref}}` (its producing step
+ *  failed / was skipped). The engine aborts rather than generate on placeholder
+ *  data — the agentic dependency guard. */
+export declare class FlowDependencyError extends FlowDependencyError_base {
+}
+
+declare const FlowDependencyError_base: Schema.TaggedErrorClass<FlowDependencyError, "FlowDependencyError", {
+    readonly _tag: Schema.tag<"FlowDependencyError">;
+} & {
+    stepId: typeof Schema.String;
+    unresolvedRef: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+
+/** A run cannot accept a human response in its current state (not `waiting`,
+ *  already answered, or cancelled). */
+export declare class FlowNotAwaitingResponse extends FlowNotAwaitingResponse_base {
+}
+
+declare const FlowNotAwaitingResponse_base: Schema.TaggedErrorClass<FlowNotAwaitingResponse, "FlowNotAwaitingResponse", {
+    readonly _tag: Schema.tag<"FlowNotAwaitingResponse">;
+} & {
+    runId: typeof Schema.String;
+    status: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+
+/** A flow (definition) could not be resolved by ref (code name or row id). */
+export declare class FlowNotFound extends FlowNotFound_base {
+}
+
+declare const FlowNotFound_base: Schema.TaggedErrorClass<FlowNotFound, "FlowNotFound", {
+    readonly _tag: Schema.tag<"FlowNotFound">;
+} & {
+    flowRef: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+
+/** A flow run row could not be found. */
+export declare class FlowRunNotFound extends FlowRunNotFound_base {
+}
+
+declare const FlowRunNotFound_base: Schema.TaggedErrorClass<FlowRunNotFound, "FlowRunNotFound", {
+    readonly _tag: Schema.tag<"FlowRunNotFound">;
+} & {
+    runId: typeof Schema.String;
+    message: typeof Schema.String;
+}>;
+
+/** The flow definition is invalid (bad step graph, unknown agent, cycle, …). */
+export declare class FlowValidationError extends FlowValidationError_base {
+}
+
+declare const FlowValidationError_base: Schema.TaggedErrorClass<FlowValidationError, "FlowValidationError", {
+    readonly _tag: Schema.tag<"FlowValidationError">;
+} & {
+    flowRef: typeof Schema.String;
+    message: typeof Schema.String;
+    /** Optional per-issue detail for the editor. */
+    issues: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+
+export { }

package/dist/errors.js

@@ -0,0 +1,29 @@
+import { Schema as e } from "effect";
+//#region src/errors.ts
+var t = class extends e.TaggedError()("FlowNotFound", {
+	flowRef: e.String,
+	message: e.String
+}) {}, n = class extends e.TaggedError()("FlowRunNotFound", {
+	runId: e.String,
+	message: e.String
+}) {}, r = class extends e.TaggedError()("FlowValidationError", {
+	flowRef: e.String,
+	message: e.String,
+	issues: e.optional(e.Array(e.String))
+}) {}, i = class extends e.TaggedError()("FlowDependencyError", {
+	stepId: e.String,
+	unresolvedRef: e.String,
+	message: e.String
+}) {}, a = class extends e.TaggedError()("FlowBriefIncomplete", {
+	missing: e.Array(e.String),
+	message: e.String
+}) {}, o = class extends e.TaggedError()("FlowNotAwaitingResponse", {
+	runId: e.String,
+	status: e.String,
+	message: e.String
+}) {}, s = class extends e.TaggedError()("FlowCapabilityMissing", {
+	capability: e.String,
+	message: e.String
+}) {};
+//#endregion
+export { a as FlowBriefIncomplete, s as FlowCapabilityMissing, i as FlowDependencyError, o as FlowNotAwaitingResponse, t as FlowNotFound, n as FlowRunNotFound, r as FlowValidationError };