@h-rig/core 0.0.6-alpha.154 → 0.0.6-alpha.156

package/dist/src/rigSelectors.js

@@ -1,414 +0,0 @@
-// @bun
-// packages/core/src/rigSelectors.ts
-function selectWorkspaces(snapshot) {
-  return snapshot?.workspaces ?? [];
-}
-function selectPrimaryWorkspace(snapshot) {
-  const workspaces = selectWorkspaces(snapshot);
-  return workspaces.find((workspace) => workspace.sourceKind === "rig-import") ?? workspaces[0] ?? null;
-}
-function pickDefaultWorkspaceId(snapshot) {
-  return selectPrimaryWorkspace(snapshot)?.id ?? null;
-}
-function selectWorkspace(snapshot, workspaceId) {
-  if (!workspaceId)
-    return null;
-  return snapshot?.workspaces.find((workspace) => workspace.id === workspaceId) ?? null;
-}
-function selectTask(snapshot, taskId) {
-  if (!taskId)
-    return null;
-  return snapshot?.tasks.find((task) => task.id === taskId) ?? null;
-}
-function selectTasksByWorkspace(snapshot, workspaceId) {
-  if (!workspaceId)
-    return [];
-  return snapshot?.tasks.filter((task) => task.workspaceId === workspaceId) ?? [];
-}
-var selectTasksForWorkspace = selectTasksByWorkspace;
-function selectTasksByStatus(snapshot, status) {
-  return snapshot?.tasks.filter((task) => task.status === status) ?? [];
-}
-function projectTaskStatusForGrouping(status) {
-  switch (status) {
-    case "failed":
-      return "ready";
-    case "closed":
-      return "completed";
-    case "running":
-    case "in_progress":
-    case "under_review":
-      return "running";
-    case null:
-    case undefined:
-    case "":
-      return "unknown";
-    default:
-      return status;
-  }
-}
-function projectRunStatusForTaskGrouping(status) {
-  switch (status) {
-    case "created":
-    case "queued":
-    case "preparing":
-      return "queued";
-    case "running":
-    case "waiting-approval":
-    case "waiting-user-input":
-    case "paused":
-    case "validating":
-    case "reviewing":
-    case "closing-out":
-      return "running";
-    case "needs-attention":
-      return "blocked";
-    case "failed":
-    case "stopped":
-      return "ready";
-    case "completed":
-      return "completed";
-    case null:
-    case undefined:
-      return null;
-  }
-}
-var STATUS_PRIORITY = [
-  "running",
-  "blocked",
-  "queued",
-  "ready",
-  "open",
-  "draft",
-  "unknown",
-  "cancelled",
-  "completed"
-];
-function taskIdFromSession(session) {
-  return session.taskId ?? session.record.taskId ?? null;
-}
-function latestSessionByTask(sessions) {
-  const byTask = new Map;
-  for (const session of sessions) {
-    const taskId = taskIdFromSession(session);
-    if (!taskId)
-      continue;
-    const existing = byTask.get(taskId);
-    if (!existing || (session.lastEventAt ?? "").localeCompare(existing.lastEventAt ?? "") >= 0) {
-      byTask.set(taskId, session);
-    }
-  }
-  return byTask;
-}
-function projectTaskStatusWithSessions(task, sessionsByTask = new Map) {
-  const sessionStatus = projectRunStatusForTaskGrouping(sessionsByTask.get(task.id)?.status);
-  return sessionStatus ?? projectTaskStatusForGrouping(task.status);
-}
-function groupTasksByProjectedStatus(tasks, sessions = []) {
-  const sessionsByTask = latestSessionByTask(sessions);
-  const byStatus = new Map;
-  for (const task of tasks) {
-    const projectedStatus = projectTaskStatusWithSessions(task, sessionsByTask);
-    const group = byStatus.get(projectedStatus);
-    if (group) {
-      group.push(task);
-    } else {
-      byStatus.set(projectedStatus, [task]);
-    }
-  }
-  const result = [];
-  for (const status of STATUS_PRIORITY) {
-    const group = byStatus.get(status);
-    if (group && group.length > 0) {
-      result.push({ status, tasks: group });
-    }
-  }
-  const overflowStatuses = Array.from(byStatus.keys()).filter((status) => !STATUS_PRIORITY.includes(status)).sort();
-  for (const status of overflowStatuses) {
-    const group = byStatus.get(status);
-    if (group && group.length > 0) {
-      result.push({ status, tasks: group });
-    }
-  }
-  return result;
-}
-function isProjectionGroupingInput(value) {
-  return Boolean(value && typeof value === "object" && !("snapshotSequence" in value) && Array.isArray(value.tasks));
-}
-function selectTasksGroupedByStatus(input, workspaceId) {
-  if (isProjectionGroupingInput(input)) {
-    const filteredTasks = input.workspaceId ? input.tasks.filter((task) => {
-      const workspaceTask = task;
-      return workspaceTask.workspaceId === input.workspaceId;
-    }) : input.tasks;
-    return groupTasksByProjectedStatus(filteredTasks, input.sessions);
-  }
-  const tasks = selectTasksByWorkspace(input, workspaceId ?? null);
-  return groupTasksByProjectedStatus(tasks, []);
-}
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeLogin(value) {
-  return value.trim().replace(/^@+/, "").toLowerCase();
-}
-function assigneeLoginsFromValue(value) {
-  if (!Array.isArray(value))
-    return [];
-  return value.flatMap((entry) => {
-    if (typeof entry === "string" && entry.trim())
-      return [normalizeLogin(entry)];
-    if (isObjectRecord(entry) && typeof entry.login === "string" && entry.login.trim()) {
-      return [normalizeLogin(entry.login)];
-    }
-    return [];
-  });
-}
-function normalizeTaskAssigneeFilter(assignee, currentUserLogin) {
-  const trimmed = assignee?.trim();
-  if (!trimmed)
-    return null;
-  if (trimmed === "@me" || trimmed.toLowerCase() === "me") {
-    return currentUserLogin?.trim() ? normalizeLogin(currentUserLogin) : null;
-  }
-  return normalizeLogin(trimmed);
-}
-function readTaskAssigneeLogins(task) {
-  const taskRecord = task;
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  const raw = isObjectRecord(metadata?.raw) ? metadata.raw : null;
-  return Array.from(new Set([
-    ...assigneeLoginsFromValue(taskRecord.assignees),
-    ...assigneeLoginsFromValue(metadata?.assignees),
-    ...assigneeLoginsFromValue(raw?.assignees)
-  ]));
-}
-function taskMatchesAssigneeFilter(task, assignee, options = {}) {
-  const normalized = normalizeTaskAssigneeFilter(assignee, options.currentUserLogin);
-  if (!normalized)
-    return false;
-  return readTaskAssigneeLogins(task).includes(normalized);
-}
-function selectTasksAssignedTo(tasks, assignee, options = {}) {
-  return tasks.filter((task) => taskMatchesAssigneeFilter(task, assignee, options));
-}
-function selectTasksAssignedToMe(tasks, currentUserLogin) {
-  return selectTasksAssignedTo(tasks, "@me", currentUserLogin === undefined ? {} : { currentUserLogin });
-}
-function selectRun(snapshot, runId) {
-  if (!runId)
-    return null;
-  return snapshot?.runs.find((run) => run.id === runId) ?? null;
-}
-function selectRunsByTask(snapshot, taskId) {
-  if (!taskId)
-    return [];
-  return snapshot?.runs.filter((run) => run.taskId === taskId) ?? [];
-}
-var selectRunsForTask = selectRunsByTask;
-function selectRunsForWorkspace(snapshot, workspaceId) {
-  if (!workspaceId)
-    return [];
-  return snapshot?.runs.filter((run) => run.workspaceId === workspaceId) ?? [];
-}
-function selectAdhocRuns(snapshot) {
-  return snapshot?.runs.filter((run) => run.taskId === null) ?? [];
-}
-function selectAdhocRunsForWorkspace(snapshot, workspaceId) {
-  if (!workspaceId)
-    return [];
-  return snapshot?.runs.filter((run) => run.taskId === null && run.workspaceId === workspaceId) ?? [];
-}
-function selectGraphsForWorkspace(snapshot, workspaceId) {
-  if (!workspaceId)
-    return [];
-  return snapshot?.graphs.filter((graph) => graph.workspaceId === workspaceId) ?? [];
-}
-function selectQueueForWorkspace(snapshot, workspaceId) {
-  if (!snapshot || !workspaceId)
-    return [];
-  const taskIds = new Set(selectTasksByWorkspace(snapshot, workspaceId).map((task) => task.id));
-  return snapshot.queue.filter((entry) => taskIds.has(entry.taskId));
-}
-function selectPendingApprovals(snapshot) {
-  return snapshot?.approvals.filter((approval) => approval.status === "pending") ?? [];
-}
-function selectApprovalsForRun(snapshot, runId) {
-  if (!runId)
-    return [];
-  return snapshot?.approvals.filter((approval) => approval.runId === runId) ?? [];
-}
-function selectPendingApprovalsForRun(snapshot, runId) {
-  return selectApprovalsForRun(snapshot, runId).filter((approval) => approval.status === "pending");
-}
-function selectApprovalsForWorkspace(snapshot, workspaceId) {
-  if (!snapshot || !workspaceId)
-    return [];
-  const runIds = new Set(selectRunsForWorkspace(snapshot, workspaceId).map((run) => run.id));
-  return snapshot.approvals.filter((approval) => runIds.has(approval.runId));
-}
-function selectUserInputsForRun(snapshot, runId) {
-  if (!runId)
-    return [];
-  return (snapshot?.userInputs ?? []).filter((request) => request.runId === runId);
-}
-function selectPendingUserInputs(snapshot) {
-  return (snapshot?.userInputs ?? []).filter((request) => request.status === "pending");
-}
-function selectPendingUserInputsForRun(snapshot, runId) {
-  return selectUserInputsForRun(snapshot, runId).filter((request) => request.status === "pending");
-}
-function selectUserInputsForWorkspace(snapshot, workspaceId) {
-  if (!snapshot || !workspaceId)
-    return [];
-  const runIds = new Set(selectRunsForWorkspace(snapshot, workspaceId).map((run) => run.id));
-  return (snapshot.userInputs ?? []).filter((request) => runIds.has(request.runId));
-}
-function selectRuntimeForRun(snapshot, runId) {
-  if (!runId)
-    return null;
-  return snapshot?.runtimes.find((runtime) => runtime.runId === runId) ?? null;
-}
-function selectLatestRuntimeForTask(snapshot, taskId) {
-  if (!taskId)
-    return null;
-  const runs = selectRunsByTask(snapshot, taskId).toSorted((left, right) => (right.startedAt ?? right.createdAt).localeCompare(left.startedAt ?? left.createdAt));
-  for (const run of runs) {
-    const runtime = selectRuntimeForRun(snapshot, run.id);
-    if (runtime)
-      return runtime;
-  }
-  return null;
-}
-function selectActionsForTask(snapshot, taskId) {
-  if (!taskId)
-    return [];
-  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
-  return snapshot?.actions.filter((action) => runIds.has(action.runId)) ?? [];
-}
-function selectApprovalsForTask(snapshot, taskId) {
-  if (!taskId)
-    return [];
-  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
-  return snapshot?.approvals.filter((approval) => runIds.has(approval.runId)) ?? [];
-}
-function selectUserInputsForTask(snapshot, taskId) {
-  if (!taskId)
-    return [];
-  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
-  return (snapshot?.userInputs ?? []).filter((request) => runIds.has(request.runId));
-}
-function selectValidationsForRun(snapshot, runId) {
-  if (!runId)
-    return [];
-  return snapshot?.validations.filter((validation) => validation.runId === runId) ?? [];
-}
-function selectValidationsForTask(snapshot, taskId) {
-  if (!taskId)
-    return [];
-  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
-  return snapshot?.validations.filter((validation) => runIds.has(validation.runId)) ?? [];
-}
-function selectFailedValidations(snapshot, runId) {
-  return selectValidationsForRun(snapshot, runId).filter((validation) => validation.status === "failed");
-}
-function selectReviewsForRun(snapshot, runId) {
-  if (!runId)
-    return [];
-  return snapshot?.reviews.filter((review) => review.runId === runId) ?? [];
-}
-function selectReviewsForTask(snapshot, taskId) {
-  if (!taskId)
-    return [];
-  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
-  return snapshot?.reviews.filter((review) => runIds.has(review.runId)) ?? [];
-}
-function selectArtifactsForRun(snapshot, runId) {
-  if (!runId)
-    return [];
-  return snapshot?.artifacts.filter((artifact) => artifact.runId === runId) ?? [];
-}
-function selectArtifactsForTask(snapshot, taskId) {
-  if (!taskId)
-    return [];
-  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
-  return snapshot?.artifacts.filter((artifact) => runIds.has(artifact.runId)) ?? [];
-}
-function selectPolicyDecisionsForTask(snapshot, taskId) {
-  if (!taskId)
-    return [];
-  const runIds = new Set(selectRunsByTask(snapshot, taskId).map((run) => run.id));
-  return snapshot?.policyDecisions.filter((decision) => runIds.has(decision.runId)) ?? [];
-}
-function selectRemoteEndpoints(snapshot) {
-  return snapshot?.remoteEndpoints ?? [];
-}
-function selectRemoteConnections(snapshot) {
-  return snapshot?.remoteConnections ?? [];
-}
-function selectRemoteEndpoint(snapshot, endpointId) {
-  if (!endpointId)
-    return null;
-  return snapshot?.remoteEndpoints.find((endpoint) => endpoint.id === endpointId) ?? null;
-}
-function selectRemoteConnection(snapshot, endpointId) {
-  if (!endpointId)
-    return null;
-  return snapshot?.remoteConnections.find((connection) => connection.endpointId === endpointId) ?? null;
-}
-function selectConnectedRemoteCount(snapshot) {
-  return selectRemoteConnections(snapshot).filter((connection) => connection.status === "connected").length;
-}
-export {
-  taskMatchesAssigneeFilter,
-  selectWorkspaces,
-  selectWorkspace,
-  selectValidationsForTask,
-  selectValidationsForRun,
-  selectUserInputsForWorkspace,
-  selectUserInputsForTask,
-  selectUserInputsForRun,
-  selectTasksGroupedByStatus,
-  selectTasksForWorkspace,
-  selectTasksByWorkspace,
-  selectTasksByStatus,
-  selectTasksAssignedToMe,
-  selectTasksAssignedTo,
-  selectTask,
-  selectRuntimeForRun,
-  selectRunsForWorkspace,
-  selectRunsForTask,
-  selectRunsByTask,
-  selectRun,
-  selectReviewsForTask,
-  selectReviewsForRun,
-  selectRemoteEndpoints,
-  selectRemoteEndpoint,
-  selectRemoteConnections,
-  selectRemoteConnection,
-  selectQueueForWorkspace,
-  selectPrimaryWorkspace,
-  selectPolicyDecisionsForTask,
-  selectPendingUserInputsForRun,
-  selectPendingUserInputs,
-  selectPendingApprovalsForRun,
-  selectPendingApprovals,
-  selectLatestRuntimeForTask,
-  selectGraphsForWorkspace,
-  selectFailedValidations,
-  selectConnectedRemoteCount,
-  selectArtifactsForTask,
-  selectArtifactsForRun,
-  selectApprovalsForWorkspace,
-  selectApprovalsForTask,
-  selectApprovalsForRun,
-  selectAdhocRunsForWorkspace,
-  selectAdhocRuns,
-  selectActionsForTask,
-  readTaskAssigneeLogins,
-  projectTaskStatusWithSessions,
-  projectTaskStatusForGrouping,
-  projectRunStatusForTaskGrouping,
-  pickDefaultWorkspaceId,
-  normalizeTaskAssigneeFilter
-};

package/dist/src/rollups.d.ts

@@ -1,6 +0,0 @@
-import type { AssigneeRollup as ContractAssigneeRollup, BlockerClass as ContractBlockerClass, EpicRollup as ContractEpicRollup, RunJournalProjection, TaskSummary } from "@rig/contracts";
-export type BlockerClass = ContractBlockerClass;
-export type EpicRollup = ContractEpicRollup;
-export type AssigneeRollup = ContractAssigneeRollup;
-export declare function rollupByEpic(tasks: readonly TaskSummary[], classifications?: ReadonlyMap<string, BlockerClass>): readonly EpicRollup[];
-export declare function rollupByAssignee(tasks: readonly TaskSummary[], runs: readonly RunJournalProjection[]): readonly AssigneeRollup[];