evolcore 0.0.1 → 0.0.3

package/dist/trigger/patch.js

@@ -0,0 +1,155 @@
+import { normalizeTriggerDefinition, parseDurationMs, TRIGGER_SCHEMA_VERSION } from './validation.js';
+const PATCH_KEYS = new Set([
+    'name',
+    'scheduleType',
+    'scheduleValue',
+    'timezone',
+    'prompt',
+    'model',
+    'effort',
+    'permissionMode',
+    'maxRuns',
+    'maxDuration',
+    'concurrency',
+    'missedPolicy',
+]);
+export function applyTriggerPatch(definition, input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('trigger patch must be an object');
+    }
+    const patch = input;
+    const keys = Object.keys(patch);
+    if (keys.length === 0)
+        throw new Error('trigger patch must contain at least one field');
+    for (const key of keys) {
+        if (!PATCH_KEYS.has(key))
+            throw new Error(`trigger update does not support field: ${key}`);
+    }
+    const updated = JSON.parse(JSON.stringify(definition));
+    if (patch.name !== undefined)
+        updated.name = String(patch.name);
+    applySourcePatch(updated, patch);
+    if (patch.prompt !== undefined) {
+        if (updated.execution.type === 'script')
+            updated.feedback.onReply = { template: String(patch.prompt) };
+        else
+            updated.execution.prompt = String(patch.prompt);
+    }
+    if (patch.model !== undefined)
+        setOptional(updated.execution, 'model', patch.model);
+    if (patch.effort !== undefined)
+        setOptional(updated.execution, 'effort', patch.effort);
+    if (patch.permissionMode !== undefined)
+        setOptional(updated.execution, 'permissionMode', patch.permissionMode);
+    if (patch.concurrency !== undefined)
+        updated.reliability.concurrency = patch.concurrency;
+    if (patch.missedPolicy !== undefined)
+        updated.reliability.missedPolicy = patch.missedPolicy;
+    if (patch.maxRuns !== undefined || patch.maxDuration !== undefined) {
+        const limits = updated.limits ? { ...updated.limits } : {};
+        if (patch.maxRuns !== undefined) {
+            if (patch.maxRuns === null)
+                delete limits.maxRuns;
+            else
+                limits.maxRuns = patch.maxRuns;
+        }
+        if (patch.maxDuration !== undefined) {
+            if (patch.maxDuration === null || patch.maxDuration === '')
+                delete limits.maxDuration;
+            else
+                limits.maxDuration = patch.maxDuration;
+        }
+        updated.limits = Object.keys(limits).length > 0 ? limits : undefined;
+    }
+    return normalizeTriggerDefinition({
+        ...updated,
+        id: definition.id,
+        agentAid: definition.agentAid,
+        createdAt: definition.createdAt,
+        updatedAt: definition.updatedAt,
+        ...(definition.origin ? { origin: definition.origin } : {}),
+    });
+}
+/**
+ * Replaces the editable Trigger V3.1 definition while keeping lifecycle and
+ * ownership fields under server control. This is the ECWeb structured-edit
+ * path; the compact CLI patch path above remains intentionally limited.
+ */
+export function replaceEditableTriggerDefinition(existing, input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('trigger definition update must be an object');
+    }
+    const editable = input;
+    const replacement = normalizeTriggerDefinition({
+        ...editable,
+        $schema_version: TRIGGER_SCHEMA_VERSION,
+        id: existing.id,
+        agentAid: existing.agentAid,
+        enabled: existing.enabled,
+        createdAt: existing.createdAt,
+        updatedAt: existing.updatedAt,
+        origin: existing.origin,
+    });
+    assertBaseagentImmutable(existing, replacement);
+    return replacement;
+}
+function assertBaseagentImmutable(existing, updated) {
+    if (existing.execution.baseagent !== updated.execution.baseagent) {
+        throw new Error('execution.baseagent is immutable; create a new Trigger to use another baseagent');
+    }
+}
+function applySourcePatch(updated, patch) {
+    const previous = updated.source;
+    if (patch.scheduleType !== undefined || patch.scheduleValue !== undefined) {
+        const current = scheduleView(previous);
+        const type = patch.scheduleType ?? current.type;
+        const value = patch.scheduleValue ?? current.value;
+        const next = sourceFromSchedule(type, value);
+        if (next.type === 'cron' && previous.type === 'cron' && patch.timezone === undefined) {
+            next.timezone = previous.timezone;
+        }
+        if (next.type === 'event' && previous.type === 'event')
+            next.filter = previous.filter;
+        updated.source = next;
+    }
+    if (patch.timezone !== undefined) {
+        if (updated.source.type !== 'cron')
+            throw new Error('timezone is only valid for a cron trigger');
+        if (patch.timezone === null || patch.timezone === '')
+            delete updated.source.timezone;
+        else
+            updated.source.timezone = String(patch.timezone);
+    }
+}
+function sourceFromSchedule(type, value) {
+    switch (type) {
+        case 'once': return { type: 'once' };
+        case 'delay': return { type: 'delay', afterMs: durationMs(value) };
+        case 'at': return { type: 'at', at: value };
+        case 'cron': return { type: 'cron', expression: value };
+        case 'interval': return { type: 'interval', everyMs: durationMs(value) };
+        case 'event': return { type: 'event', eventPattern: value };
+    }
+}
+function scheduleView(source) {
+    switch (source.type) {
+        case 'once': return { type: 'once', value: '' };
+        case 'delay': return { type: 'delay', value: String(source.afterMs) };
+        case 'at': return { type: 'at', value: source.at };
+        case 'cron': return { type: 'cron', value: source.expression };
+        case 'interval': return { type: 'interval', value: String(source.everyMs) };
+        case 'event': return { type: 'event', value: source.eventPattern };
+    }
+}
+function durationMs(value) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric) && numeric > 0)
+        return numeric;
+    return parseDurationMs(value);
+}
+function setOptional(object, key, value) {
+    if (value === null || value === '')
+        delete object[key];
+    else
+        object[key] = value;
+}