@zq-silk/yui 0.2.0 → 0.4.2

package/dist/web/webSnapshot.js

@@ -0,0 +1,148 @@
+import { isRoleRunStalled } from "../scheduler/roleRunStall.js";
+import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
+export function buildWebDashboardSnapshot(store, now = new Date()) {
+    return store.transaction((reader) => {
+        const statusCounts = {
+            draft: 0,
+            active: 0,
+            completed: 0,
+            retired: 0,
+            archived: 0
+        };
+        const projectNames = new Map(reader.listProjects().map((project) => [project.id, project.name]));
+        let openInputs = 0;
+        const attention = [];
+        const tasks = reader.listTasks().map((task) => {
+            statusCounts[task.status] += 1;
+            const taskOpenInputs = reader.listInputRequests(task.id)
+                .filter((request) => request.status === "open").length;
+            openInputs += taskOpenInputs;
+            const taskOpen = reader.listInputRequests(task.id)
+                .filter((request) => request.status === "open");
+            for (const request of taskOpen) {
+                attention.push({ taskId: task.id, taskTitle: task.title, request });
+            }
+            const events = reader.listEvents?.(task.id) ?? [];
+            const needsAttentionCount = reader.listAgentRuns(task.id)
+                .filter((run) => run.status === "active" && isRoleRunStalled(events, run.id))
+                .length;
+            const execution = buildTaskExecutionProjection(reader, task.id);
+            const names = task.projectBindings.flatMap(({ projectId }) => {
+                const name = projectNames.get(projectId);
+                return name === undefined ? [] : [name];
+            });
+            return {
+                ...task,
+                ...(names.length === 0 ? {} : { projectNames: names }),
+                workItems: countWorkItems(reader.listWorkItems(task.id)),
+                roleCount: reader.listRoles(task.id).length,
+                openInputCount: taskOpenInputs,
+                needsAttentionCount,
+                execution
+            };
+        }).sort(compareDashboardTasks);
+        return {
+            generatedAt: now.toISOString(),
+            counts: { total: tasks.length, ...statusCounts, openInputs },
+            attention: attention.sort(compareAttention),
+            tasks
+        };
+    });
+}
+export function buildWebTaskDetail(store, taskId) {
+    return store.transaction((reader) => {
+        const task = reader.getTask(taskId);
+        if (task === null)
+            return null;
+        const inputs = reader.listInputRequests(taskId);
+        const projectNamesById = new Map(reader.listProjects().map((project) => [project.id, project.name]));
+        const projectNames = task.projectBindings.flatMap(({ projectId }) => {
+            const name = projectNamesById.get(projectId);
+            return name === undefined ? [] : [name];
+        });
+        const runs = reader.listAgentRuns(taskId);
+        const events = reader.listEvents?.(taskId) ?? [];
+        const needsAttentionRuns = runs
+            .filter((run) => run.status === "active" && isRoleRunStalled(events, run.id))
+            .map((run) => ({
+            runId: run.id,
+            roleName: run.roleName,
+            progressAt: latestStallProgress(events, run.id),
+            kind: latestStallField(events, run.id, "kind") ?? "execution-stalled",
+            classification: latestStallField(events, run.id, "classification") ?? "truly-stalled"
+        }));
+        const activeRuns = new Map(runs
+            .filter((run) => run.status === "active")
+            .map((run) => [run.roleName, run]));
+        const roles = reader.listRoles(taskId).map((role) => {
+            const activeRun = activeRuns.get(role.name);
+            const sessions = reader.getTaskRoleSessionSet(taskId, role.name);
+            const activeSession = sessions?.sessions[sessions.activeAgentId];
+            const effectiveLaunch = activeRun?.effective ?? activeSession?.effective ?? null;
+            return {
+                ...role,
+                effectiveLaunch,
+                effectiveLaunchSource: activeRun === undefined
+                    ? activeSession === undefined ? null : "session"
+                    : "run",
+                launchDrift: effectiveLaunch !== null
+                    && effectiveLaunch.sourceDesiredRevision !== role.launchRevision
+            };
+        });
+        return {
+            task: projectNames.length === 0 ? task : { ...task, projectNames },
+            execution: buildTaskExecutionProjection(reader, taskId),
+            brief: reader.getTaskBrief(taskId),
+            roles,
+            workItems: reader.listWorkItems(taskId),
+            runs,
+            runtimeHealth: { needsAttentionRuns },
+            reviewRounds: reader.listReviewRounds(taskId),
+            openInputs: inputs.filter((request) => request.status === "open"),
+            messages: reader.listMessages(taskId),
+            decisions: reader.listDecisions(taskId),
+            milestones: reader.listMilestones(taskId)
+        };
+    });
+}
+function latestStallProgress(events, runId) {
+    return latestStallField(events, runId, "progressAt");
+}
+function latestStallField(events, runId, field) {
+    const stalled = events
+        .filter((event) => event.type === "run.stalled" && event.payload.runId === runId)
+        .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
+    return stalled?.payload[field];
+}
+function countWorkItems(items) {
+    const counts = {
+        total: items.length,
+        pending: 0,
+        running: 0,
+        awaiting_acceptance: 0,
+        completed: 0,
+        failed: 0,
+        retired: 0
+    };
+    const mutable = counts;
+    for (const item of items) {
+        mutable[item.status] += 1;
+    }
+    return counts;
+}
+function compareDashboardTasks(left, right) {
+    const statusOrder = {
+        active: 0,
+        draft: 1,
+        completed: 2,
+        retired: 3,
+        archived: 4
+    };
+    return statusOrder[left.status] - statusOrder[right.status]
+        || Date.parse(right.updatedAt) - Date.parse(left.updatedAt)
+        || left.id.localeCompare(right.id);
+}
+function compareAttention(left, right) {
+    return Date.parse(left.request.createdAt) - Date.parse(right.request.createdAt)
+        || left.request.id.localeCompare(right.request.id);
+}