@zq-silk/yui 0.2.0 → 0.4.2

package/dist/executor/turnCompletion.js

@@ -0,0 +1,126 @@
+import { requireSafeIdentity, requireText, requireTimestamp } from "../runtime/validation.js";
+export const DEFAULT_RECENT_TURN_ID_LIMIT = 32;
+const PENDING_TURN_COMPLETION_FIELDS = [
+    "schemaVersion",
+    "taskId",
+    "roleName",
+    "agentId",
+    "nativeSessionId",
+    "turnId",
+    "runId",
+    "summary",
+    "observedAt",
+    "dueAt"
+];
+export function createPendingTurnCompletion(input) {
+    const observedAt = requireTimestamp(input.observedAt, "Turn observedAt");
+    const dueAt = requireTimestamp(input.dueAt, "Turn dueAt");
+    requireOrderedTimestamps(observedAt, dueAt);
+    return {
+        schemaVersion: 1,
+        taskId: requireSafeIdentity(input.taskId, "Task id"),
+        roleName: requireSafeIdentity(input.roleName, "Role name"),
+        agentId: requireSafeIdentity(input.agentId, "Agent id"),
+        nativeSessionId: requireText(input.nativeSessionId, "Native session id"),
+        turnId: requireSafeIdentity(input.turnId, "Turn id"),
+        runId: requireSafeIdentity(input.runId, "Run id"),
+        summary: requireText(input.summary, "Turn summary"),
+        observedAt,
+        dueAt
+    };
+}
+export function validatePendingTurnCompletion(value) {
+    const input = requireRecord(value, "PendingTurnCompletion");
+    requireExactFields(input, PENDING_TURN_COMPLETION_FIELDS, "PendingTurnCompletion");
+    if (input.schemaVersion !== 1) {
+        throw new Error("PendingTurnCompletion must use schemaVersion 1.");
+    }
+    const observedAt = requirePersistedTimestamp(input.observedAt, "PendingTurnCompletion observedAt");
+    const dueAt = requirePersistedTimestamp(input.dueAt, "PendingTurnCompletion dueAt");
+    requireOrderedTimestamps(observedAt, dueAt);
+    return {
+        schemaVersion: 1,
+        taskId: requireSafeIdentityValue(input.taskId, "Task id"),
+        roleName: requireSafeIdentityValue(input.roleName, "Role name"),
+        agentId: requireSafeIdentityValue(input.agentId, "Agent id"),
+        nativeSessionId: requireTextValue(input.nativeSessionId, "Native session id"),
+        turnId: requireSafeIdentityValue(input.turnId, "Turn id"),
+        runId: requireSafeIdentityValue(input.runId, "Run id"),
+        summary: requireTextValue(input.summary, "Turn summary"),
+        observedAt,
+        dueAt
+    };
+}
+export function validateRecentTurnIds(value, limit = DEFAULT_RECENT_TURN_ID_LIMIT) {
+    const normalizedLimit = requireLimit(limit);
+    if (!Array.isArray(value))
+        throw new Error("Recent Turn ids must be an array.");
+    if (value.length > normalizedLimit) {
+        throw new Error(`Recent Turn ids must not contain more than ${normalizedLimit} entries.`);
+    }
+    const result = value.map((turnId) => requireSafeIdentityValue(turnId, "Recent Turn id"));
+    if (new Set(result).size !== result.length) {
+        throw new Error("Recent Turn ids must not contain duplicates.");
+    }
+    return result;
+}
+export function rememberRecentTurnId(recentTurnIds, turnId, limit = DEFAULT_RECENT_TURN_ID_LIMIT) {
+    const normalizedLimit = requireLimit(limit);
+    const existing = validateRecentTurnIds(recentTurnIds, normalizedLimit);
+    const normalizedTurnId = requireSafeIdentity(turnId, "Recent Turn id");
+    return [
+        ...existing.filter((candidate) => candidate !== normalizedTurnId),
+        normalizedTurnId
+    ].slice(-normalizedLimit);
+}
+export function hasRecentTurnId(recentTurnIds, turnId) {
+    const existing = validateRecentTurnIds(recentTurnIds);
+    return existing.includes(requireSafeIdentity(turnId, "Recent Turn id"));
+}
+function requireOrderedTimestamps(observedAt, dueAt) {
+    if (Date.parse(dueAt) < Date.parse(observedAt)) {
+        throw new Error("PendingTurnCompletion dueAt must not be earlier than observedAt.");
+    }
+}
+function requirePersistedTimestamp(value, label) {
+    if (typeof value !== "string")
+        throw new Error(`${label} must be a valid timestamp.`);
+    const timestamp = Date.parse(value);
+    if (!Number.isFinite(timestamp))
+        throw new Error(`${label} must be a valid timestamp.`);
+    const canonical = new Date(timestamp).toISOString();
+    if (value !== canonical)
+        throw new Error(`${label} must be a canonical timestamp.`);
+    return canonical;
+}
+function requireRecord(value, label) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    return value;
+}
+function requireExactFields(value, fields, label) {
+    const expected = new Set(fields);
+    const unknown = Object.keys(value).find((field) => !expected.has(field));
+    if (unknown !== undefined)
+        throw new Error(`${label} has unknown field: ${unknown}.`);
+    const missing = fields.find((field) => !Object.hasOwn(value, field));
+    if (missing !== undefined)
+        throw new Error(`${label} is missing field: ${missing}.`);
+}
+function requireSafeIdentityValue(value, label) {
+    if (typeof value !== "string")
+        throw new Error(`${label} is invalid.`);
+    return requireSafeIdentity(value, label);
+}
+function requireTextValue(value, label) {
+    if (typeof value !== "string")
+        throw new Error(`${label} is invalid.`);
+    return requireText(value, label);
+}
+function requireLimit(value) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error("Recent Turn id limit must be a positive integer.");
+    }
+    return value;
+}

package/dist/input/inputRequest.js

@@ -1,3 +1,4 @@
+import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 export class InputRequestStateError extends Error {
     requestId;
     status;
@@ -13,7 +14,7 @@ export function createInputRequest(id, taskId, requester, input, now) {
     const timestamp = requireDate(now, "Input request creation time");
     const choices = normalizeChoices(input.choices);
     return validateInputRequest({
-        schemaVersion: 1,
+        schemaVersion: 2,
         id: requireIdentity(id, "Input request id"),
         taskId: requireIdentity(taskId, "Input request Task id"),
         requester: normalizeRequester(requester),
@@ -71,12 +72,12 @@ export function validateInputRequest(value) {
         "schemaVersion", "id", "taskId", "requester", "question", "choices",
         "blockedRefs", "policy", "status", "createdAt", "updatedAt", ...terminalField
     ], "Input request");
-    if (request.schemaVersion !== 1)
-        throw new Error("Input request must use schemaVersion 1.");
+    if (request.schemaVersion !== 2)
+        throw new Error("Input request must use schemaVersion 2.");
     const choices = validateChoices(request.choices);
     const createdAt = requireTimestamp(request.createdAt, "Input request createdAt");
     const base = {
-        schemaVersion: 1,
+        schemaVersion: 2,
         id: requireIdentity(request.id, "Input request id"),
         taskId: requireIdentity(request.taskId, "Input request Task id"),
         requester: normalizeRequester(request.requester),
@@ -87,6 +88,18 @@ export function validateInputRequest(value) {
         createdAt,
         updatedAt: requireTimestamp(request.updatedAt, "Input request updatedAt")
     };
+    validateTaskRecordReference({ taskId: base.taskId, localId: base.id }, "inputRequest");
+    validateTaskRecordReference({
+        taskId: base.requester.taskId,
+        localId: base.requester.runId
+    }, "agentRun");
+    for (const reference of base.blockedRefs) {
+        validateTaskRecordReference({ taskId: reference.taskId, localId: reference.id }, reference.type === "run" ? "agentRun" : "workItem");
+    }
+    if (base.requester.taskId !== base.taskId
+        || base.blockedRefs.some(({ taskId }) => taskId !== base.taskId)) {
+        throw new Error("Input request references must belong to its Task.");
+    }
     if (Date.parse(base.updatedAt) < Date.parse(base.createdAt)) {
         throw new Error("Input request updatedAt cannot precede createdAt.");
     }
@@ -161,13 +174,17 @@ function normalizeBlockedRefs(value) {
         throw new Error("Input blocked references must be an array.");
     const references = value.map((reference) => {
         const item = record(reference, "Input blocked reference");
-        exact(item, ["type", "id"], "Input blocked reference");
+        exact(item, ["type", "taskId", "id"], "Input blocked reference");
         if (item.type !== "work-item" && item.type !== "run") {
             throw new Error("Input blocked reference type must be work-item or run.");
         }
-        return { type: item.type, id: requireIdentity(item.id, "Input blocked reference id") };
+        return {
+            type: item.type,
+            taskId: requireIdentity(item.taskId, "Input blocked reference Task id"),
+            id: requireIdentity(item.id, "Input blocked reference id")
+        };
     });
-    const keys = references.map(({ type, id }) => `${type}:${id}`);
+    const keys = references.map(({ type, taskId, id }) => `${type}:${taskId}/${id}`);
     if (new Set(keys).size !== keys.length)
         throw new Error("Input blocked references must be unique.");
     return references;
@@ -207,11 +224,12 @@ function validateBlockedRefs(value) {
 function normalizeRequester(value) {
     const requester = record(value, "Input requester");
     exact(requester, requester.nativeSessionId === undefined
-        ? ["roleName", "agentId", "runId"]
-        : ["roleName", "agentId", "runId", "nativeSessionId"], "Input requester");
+        ? ["taskId", "roleName", "agentId", "runId"]
+        : ["taskId", "roleName", "agentId", "runId", "nativeSessionId"], "Input requester");
     if (requester.roleName !== "leader")
         throw new Error("Input requester must be the Task Leader.");
     return {
+        taskId: requireIdentity(requester.taskId, "Input requester Task id"),
         roleName: "leader",
         agentId: requireIdentity(requester.agentId, "Input requester Agent id"),
         runId: requireIdentity(requester.runId, "Input requester Run id"),
@@ -228,6 +246,9 @@ function normalizeAnswer(request, answer) {
         exact(value, ["text"], "Input answer");
         return { text: requireText(value.text, "Input answer") };
     }
+    if (value.text !== undefined) {
+        throw new Error("Choice input request requires a choice answer.");
+    }
     exact(value, ["choiceKey"], "Input answer");
     const key = requireChoiceKey(value.choiceKey);
     const choice = request.choices.find((candidate) => candidate.key === key);

package/dist/integration/changeSet.js

@@ -0,0 +1,36 @@
+import { normalizedUniqueText, requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
+import { validateTaskRecordReference } from "../task/taskRecordReference.js";
+export function createWorkItemChangeSet(input, now) {
+    return validateChangeSet({
+        schemaVersion: 2,
+        ...input,
+        changedPaths: [...input.changedPaths],
+        createdAt: now.toISOString()
+    });
+}
+export function validateChangeSet(changeSet) {
+    if (changeSet.schemaVersion !== 2)
+        throw new Error("ChangeSet must use schemaVersion 2.");
+    validateTaskRecordReference({ taskId: changeSet.taskId, localId: changeSet.id }, "changeSet");
+    validateTaskRecordReference({
+        taskId: changeSet.taskId,
+        localId: changeSet.workItemId
+    }, "workItem");
+    requireIdentity(changeSet.projectId, "Project id");
+    requireCommit(changeSet.baseCommit, "ChangeSet base commit");
+    requireCommit(changeSet.headCommit, "ChangeSet head commit");
+    if (changeSet.baseCommit === changeSet.headCommit) {
+        throw new Error("ChangeSet must contain at least one commit.");
+    }
+    requireText(changeSet.branch, "ChangeSet branch");
+    normalizedUniqueText(changeSet.changedPaths, "ChangeSet path");
+    requireTimestamp(changeSet.createdAt, "ChangeSet createdAt");
+    return changeSet;
+}
+function requireCommit(value, label) {
+    const normalized = requireText(value, label).toLowerCase();
+    if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/u.test(normalized)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return normalized;
+}

package/dist/integration/checkResult.js

@@ -0,0 +1,24 @@
+import { requireText } from "../domain/validation.js";
+export function normalizeCheckResult(check) {
+    if (!["passed", "failed", "skipped"].includes(check.outcome)) {
+        throw new Error(`Check outcome is invalid: ${String(check.outcome)}.`);
+    }
+    return {
+        name: requireText(check.name, "Check name"),
+        outcome: check.outcome,
+        ...(check.details === undefined
+            ? {}
+            : { details: requireText(check.details, "Check details") }),
+        ...(check.logPath === undefined
+            ? {}
+            : { logPath: requireRelativePath(check.logPath, "Check log path") })
+    };
+}
+function requireRelativePath(value, label) {
+    const normalized = requireText(value, label);
+    if (/^(?:[A-Za-z]:[\\/]|[\\/])/u.test(normalized)
+        || normalized.split(/[\\/]/u).includes("..")) {
+        throw new Error(`${label} must be relative.`);
+    }
+    return normalized.replaceAll("\\", "/");
+}