@zq-silk/yui 0.15.12 → 0.16.0

package/dist/commands/taskCommandSupport.js

@@ -0,0 +1,155 @@
+import { taskNotFound, usageError } from "../errors/cliError.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { formatTimestamp } from "../output/timePresentation.js";
+import { SYSTEM_LEADER_ROLE as LEADER_ROLE } from "../role/systemRoles.js";
+import { currentManagedRuntime } from "../runtime/managedCaller.js";
+import { taskLocalActor as resolveTaskLocalActor } from "../task/taskAuthority.js";
+export function recordTaskEvent(store, taskId, type, payload, now) {
+    return recordTaskEventRecord(store, taskId, type, payload, now);
+}
+export function leaderActionEventPayload(store, taskId, options) {
+    const caller = currentManagedRuntime(store, options.environment, taskId, "leader");
+    // A long-lived Session may be handling direct input while another request
+    // awaits admission. The Role's active pointer cannot prove command origin.
+    return caller === undefined ? {} : { leaderNativeSessionId: caller.nativeSessionId };
+}
+export function recordTaskEventRecord(store, taskId, type, payload, now) {
+    const event = createTaskEvent(store.nextEventId(taskId), taskId, type, payload, now);
+    store.saveEvent(taskId, event);
+    return event;
+}
+export function requireTask(store, taskId) {
+    const id = requiredText(taskId, "Task id");
+    const task = store.getTask(id);
+    if (task === null)
+        throw taskNotFound(id);
+    return task;
+}
+export function assertTaskOpen(task) {
+    if (task.status === "completed") {
+        throw usageError(`Task ${task.id} is completed; reopen it before continuing.`);
+    }
+    if (task.status === "archived")
+        throw usageError(`Task is archived: ${task.id}.`);
+    if (task.status === "cancelled")
+        throw usageError(`Task is retired: ${task.id}.`);
+}
+export function taskActor(store, options, taskId) {
+    return resolveTaskLocalActor(store, options.environment, taskId);
+}
+export function parseMultiValueTail(args, valueOptions, repeatOptions, usage, flagOptions = new Set()) {
+    const positionals = [];
+    const options = new Map();
+    const multiOptions = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        if (!valueOptions.has(value) && !repeatOptions.has(value) && !flagOptions.has(value)) {
+            throw usageError(`Unsupported option: ${value}.`, usage);
+        }
+        if (flagOptions.has(value)) {
+            if (options.has(value))
+                throw usageError(`Option may only be specified once: ${value}.`, usage);
+            options.set(value, "");
+            continue;
+        }
+        if (repeatOptions.has(value)) {
+            const optionValue = args[index + 1];
+            if (optionValue === undefined || optionValue.startsWith("--")) {
+                throw usageError(`${value} is required.`, usage);
+            }
+            const existing = multiOptions.get(value) ?? [];
+            multiOptions.set(value, [...existing, optionValue]);
+            index += 1;
+            continue;
+        }
+        if (options.has(value))
+            throw usageError(`Option may only be specified once: ${value}.`, usage);
+        const optionValue = args[index + 1];
+        if (optionValue === undefined || optionValue.startsWith("--")) {
+            throw usageError(`${value} is required.`, usage);
+        }
+        options.set(value, optionValue);
+        index += 1;
+    }
+    return { positionals, options, multiOptions };
+}
+export function parseTail(args, valueOptions, usage, flagOptions = new Set()) {
+    const positionals = [];
+    const options = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        if (!valueOptions.has(value) && !flagOptions.has(value)) {
+            throw usageError(`Unsupported option: ${value}.`, usage);
+        }
+        if (options.has(value))
+            throw usageError(`Option may only be specified once: ${value}.`, usage);
+        if (flagOptions.has(value)) {
+            options.set(value, "");
+            continue;
+        }
+        const optionValue = args[index + 1];
+        if (optionValue === undefined || optionValue.startsWith("--")) {
+            throw usageError(`${value} is required.`, usage);
+        }
+        options.set(value, optionValue);
+        index += 1;
+    }
+    return { positionals, options };
+}
+export function requiredOption(options, name) {
+    return requiredText(options.get(name), name);
+}
+export function optionalNonEmptyOption(options, name) {
+    if (!options.has(name))
+        return undefined;
+    return requiredText(options.get(name), name);
+}
+export function exactPositionals(values, count, usage) {
+    if (values.length !== count || values.some((value) => value.trim().length === 0)) {
+        throw usageError(usage);
+    }
+}
+export function requiredText(value, label) {
+    const normalized = value?.trim();
+    if (normalized === undefined || normalized.length === 0)
+        throw usageError(`${label} is required.`);
+    return normalized;
+}
+export function trimmed(value) {
+    const normalized = value?.trim();
+    return normalized === undefined || normalized.length === 0 ? undefined : normalized;
+}
+export function presentTime(value, timeZone) {
+    return formatTimestamp(value, timeZone);
+}
+export function output(value, data) {
+    return data === undefined
+        ? { kind: "output", output: value }
+        : { kind: "output", output: value, data };
+}
+export function clock(options) {
+    return options.now?.() ?? new Date();
+}
+export function taskMailbox(taskId) {
+    return { kind: "task", taskId };
+}
+export function roleMailbox(taskId, roleName) {
+    return { kind: "role", taskId, roleName };
+}
+export function leaderMailbox(taskId) {
+    return roleMailbox(taskId, LEADER_ROLE);
+}
+export function taskRef(id) {
+    return { type: "task", id };
+}
+export function notifyMailbox(runtime, target) {
+    void runtime?.notifyMailboxChanged(target);
+}

package/dist/commands/taskCommandTypes.js

@@ -0,0 +1 @@
+export {};