@h-rig/rig-extension 0.0.6-alpha.91

package/dist/src/workflow/projections.js

@@ -0,0 +1,389 @@
+// @bun
+// packages/rig-extension/src/workflow/projections.ts
+var RIG_WORKFLOW_STARTED = "rig.workflow.started";
+var RIG_WORKFLOW_TARGET_SELECTED = "rig.workflow.target.selected";
+var RIG_WORKFLOW_TASK_SELECTED = "rig.workflow.task.selected";
+var RIG_WORKFLOW_STATUS_CHANGED = "rig.workflow.status.changed";
+var RIG_WORKFLOW_OPERATOR_NOTE = "rig.workflow.operator.note";
+var RIG_WORKFLOW_INBOX_REQUESTED = "rig.workflow.inbox.requested";
+var RIG_WORKFLOW_INBOX_RESOLVED = "rig.workflow.inbox.resolved";
+var EMPTY_PROJECTION = {
+  started: null,
+  target: null,
+  task: null,
+  status: null,
+  notes: [],
+  inbox: [],
+  resolvedInbox: [],
+  updatedAt: null
+};
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function requiredString(value) {
+  const text = optionalString(value);
+  return text ?? null;
+}
+function timestamp(value) {
+  const text = requiredString(value);
+  if (!text)
+    return null;
+  const millis = Date.parse(text);
+  return Number.isFinite(millis) ? text : null;
+}
+function newer(left, right) {
+  if (!right)
+    return false;
+  if (!left)
+    return true;
+  return Date.parse(right) >= Date.parse(left);
+}
+function isWorkflowTarget(value) {
+  return value === "local" || value === "remote";
+}
+function isWorkflowStatus(value) {
+  return value === "starting" || value === "running" || value === "waiting-approval" || value === "waiting-input" || value === "completed" || value === "failed" || value === "stopped";
+}
+function isInboxKind(value) {
+  return value === "approval" || value === "input";
+}
+function isInboxDecision(value) {
+  return value === "approved" || value === "rejected" || value === "answered";
+}
+function parseOwner(value) {
+  const record = asRecord(value);
+  if (!record)
+    return null;
+  const githubUserId = requiredString(record.githubUserId);
+  const login = requiredString(record.login);
+  const namespaceKey = requiredString(record.namespaceKey);
+  return githubUserId && login && namespaceKey ? { githubUserId, login, namespaceKey } : null;
+}
+function parseStringArray(value) {
+  if (!Array.isArray(value))
+    return;
+  const options = value.map(optionalString).filter((option) => option !== undefined);
+  return options.length > 0 ? options : undefined;
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function entryUpdatedAt(entry) {
+  if ("createdAt" in entry)
+    return entry.createdAt;
+  if ("selectedAt" in entry)
+    return entry.selectedAt;
+  if ("changedAt" in entry)
+    return entry.changedAt;
+  if ("notedAt" in entry)
+    return entry.notedAt;
+  if ("requestedAt" in entry)
+    return entry.requestedAt;
+  return entry.resolvedAt;
+}
+function createWorkflowStarted(input) {
+  return {
+    schemaVersion: 1,
+    workflowId: input.workflowId,
+    target: input.target,
+    selectedRepo: input.selectedRepo,
+    owner: input.owner,
+    createdAt: input.createdAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowTargetSelected(input) {
+  return {
+    schemaVersion: 1,
+    target: input.target,
+    ...input.reason ? { reason: input.reason } : {},
+    selectedAt: input.selectedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowTaskSelected(input) {
+  return {
+    schemaVersion: 1,
+    taskId: input.taskId,
+    ...input.title ? { title: input.title } : {},
+    selectedAt: input.selectedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowStatusChanged(input) {
+  return {
+    schemaVersion: 1,
+    status: input.status,
+    ...input.detail ? { detail: input.detail } : {},
+    changedAt: input.changedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowOperatorNote(input) {
+  return {
+    schemaVersion: 1,
+    ...input.noteId ? { noteId: input.noteId } : {},
+    note: input.note,
+    notedAt: input.notedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowInboxRequested(input) {
+  return {
+    schemaVersion: 1,
+    requestId: input.requestId,
+    kind: input.kind,
+    title: input.title,
+    ...input.body ? { body: input.body } : {},
+    ...input.options && input.options.length > 0 ? { options: input.options } : {},
+    requestedAt: input.requestedAt ?? new Date().toISOString()
+  };
+}
+function createWorkflowInboxResolved(input) {
+  const base = {
+    schemaVersion: 1,
+    requestId: input.requestId,
+    decision: input.decision,
+    resolvedAt: input.resolvedAt ?? new Date().toISOString()
+  };
+  return hasOwn(input, "answer") ? { ...base, answer: input.answer } : base;
+}
+function parseWorkflowStarted(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const workflowId = requiredString(record.workflowId);
+  const target = optionalString(record.target);
+  const selectedRepo = requiredString(record.selectedRepo);
+  const owner = parseOwner(record.owner);
+  const createdAt = timestamp(record.createdAt);
+  if (!workflowId || !isWorkflowTarget(target) || !selectedRepo || !owner || !createdAt)
+    return null;
+  return {
+    schemaVersion: 1,
+    workflowId,
+    target,
+    selectedRepo,
+    owner,
+    createdAt
+  };
+}
+function parseWorkflowTargetSelected(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const target = optionalString(record.target);
+  const selectedAt = timestamp(record.selectedAt);
+  if (!isWorkflowTarget(target) || !selectedAt)
+    return null;
+  const reason = optionalString(record.reason);
+  return {
+    schemaVersion: 1,
+    target,
+    ...reason ? { reason } : {},
+    selectedAt
+  };
+}
+function parseWorkflowTaskSelected(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const taskId = requiredString(record.taskId);
+  const selectedAt = timestamp(record.selectedAt);
+  if (!taskId || !selectedAt)
+    return null;
+  const title = optionalString(record.title);
+  return { schemaVersion: 1, taskId, ...title ? { title } : {}, selectedAt };
+}
+function parseWorkflowStatusChanged(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const status = optionalString(record.status);
+  const changedAt = timestamp(record.changedAt);
+  if (!changedAt || !isWorkflowStatus(status))
+    return null;
+  const detail = optionalString(record.detail);
+  return { schemaVersion: 1, status, ...detail ? { detail } : {}, changedAt };
+}
+function parseWorkflowOperatorNote(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const note = requiredString(record.note);
+  const notedAt = timestamp(record.notedAt);
+  if (!note || !notedAt)
+    return null;
+  const noteId = optionalString(record.noteId);
+  return { schemaVersion: 1, ...noteId ? { noteId } : {}, note, notedAt };
+}
+function parseWorkflowInboxRequested(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const requestId = requiredString(record.requestId);
+  const kind = optionalString(record.kind);
+  const title = requiredString(record.title);
+  const requestedAt = timestamp(record.requestedAt);
+  if (!requestId || !isInboxKind(kind) || !title || !requestedAt)
+    return null;
+  const body = optionalString(record.body);
+  const options = parseStringArray(record.options);
+  return {
+    schemaVersion: 1,
+    requestId,
+    kind,
+    title,
+    ...body ? { body } : {},
+    ...options ? { options } : {},
+    requestedAt
+  };
+}
+function parseWorkflowInboxResolved(data) {
+  const record = asRecord(data);
+  if (!record || record.schemaVersion !== 1)
+    return null;
+  const requestId = requiredString(record.requestId);
+  const decision = optionalString(record.decision);
+  const resolvedAt = timestamp(record.resolvedAt);
+  if (!requestId || !isInboxDecision(decision) || !resolvedAt)
+    return null;
+  const base = { schemaVersion: 1, requestId, decision, resolvedAt };
+  return hasOwn(record, "answer") ? { ...base, answer: record.answer } : base;
+}
+function collectPendingInboxRequests(entries) {
+  const requested = new Map;
+  const resolved = new Map;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_INBOX_REQUESTED) {
+      const request = parseWorkflowInboxRequested(entry.data);
+      if (request && newer(requested.get(request.requestId)?.requestedAt, request.requestedAt))
+        requested.set(request.requestId, request);
+    } else if (entry.customType === RIG_WORKFLOW_INBOX_RESOLVED) {
+      const resolution = parseWorkflowInboxResolved(entry.data);
+      if (resolution && newer(resolved.get(resolution.requestId), resolution.resolvedAt))
+        resolved.set(resolution.requestId, resolution.resolvedAt);
+    }
+  }
+  for (const [requestId, request] of requested) {
+    const resolvedAt = resolved.get(requestId);
+    if (resolvedAt && Date.parse(resolvedAt) >= Date.parse(request.requestedAt))
+      requested.delete(requestId);
+  }
+  return Array.from(requested.values()).sort((a, b) => Date.parse(b.requestedAt) - Date.parse(a.requestedAt));
+}
+function collectResolvedInboxRequests(entries) {
+  const requested = new Map;
+  const resolved = new Map;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_INBOX_REQUESTED) {
+      const request = parseWorkflowInboxRequested(entry.data);
+      if (request && newer(requested.get(request.requestId), request.requestedAt))
+        requested.set(request.requestId, request.requestedAt);
+    } else if (entry.customType === RIG_WORKFLOW_INBOX_RESOLVED) {
+      const resolution = parseWorkflowInboxResolved(entry.data);
+      if (resolution && newer(resolved.get(resolution.requestId)?.resolvedAt, resolution.resolvedAt)) {
+        resolved.set(resolution.requestId, resolution);
+      }
+    }
+  }
+  for (const [requestId, resolution] of resolved) {
+    const requestedAt = requested.get(requestId);
+    if (requestedAt && Date.parse(requestedAt) > Date.parse(resolution.resolvedAt))
+      resolved.delete(requestId);
+  }
+  return Array.from(resolved.values()).sort((a, b) => Date.parse(b.resolvedAt) - Date.parse(a.resolvedAt));
+}
+function projectCollabWorkflowMarker(collab) {
+  const status = createWorkflowStatusChanged({
+    status: collab.stale ? "stopped" : "running",
+    detail: collab.stale ? "Stale OMP collab session discovered from the sanctioned collab registry." : "Live OMP collab session discovered from the sanctioned collab registry.",
+    changedAt: collab.updatedAt
+  });
+  return {
+    started: null,
+    target: null,
+    task: null,
+    status,
+    notes: [],
+    inbox: [],
+    resolvedInbox: [],
+    updatedAt: newer(collab.startedAt, collab.updatedAt) ? collab.updatedAt : collab.startedAt
+  };
+}
+function projectWorkflowEntries(entries) {
+  let started = null;
+  let target = null;
+  let task = null;
+  let status = null;
+  const notes = [];
+  let updatedAt = null;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType === RIG_WORKFLOW_STARTED) {
+      const parsed = parseWorkflowStarted(entry.data);
+      if (parsed && newer(started?.createdAt, parsed.createdAt))
+        started = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_TARGET_SELECTED) {
+      const parsed = parseWorkflowTargetSelected(entry.data);
+      if (parsed && newer(target?.selectedAt, parsed.selectedAt))
+        target = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_TASK_SELECTED) {
+      const parsed = parseWorkflowTaskSelected(entry.data);
+      if (parsed && newer(task?.selectedAt, parsed.selectedAt))
+        task = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_STATUS_CHANGED) {
+      const parsed = parseWorkflowStatusChanged(entry.data);
+      if (parsed && newer(status?.changedAt, parsed.changedAt))
+        status = parsed;
+    } else if (entry.customType === RIG_WORKFLOW_OPERATOR_NOTE) {
+      const parsed = parseWorkflowOperatorNote(entry.data);
+      if (parsed)
+        notes.push(parsed);
+    }
+  }
+  notes.sort((a, b) => Date.parse(b.notedAt) - Date.parse(a.notedAt));
+  for (const value of [started, target, task, status, ...notes].map((entry) => entry ? entryUpdatedAt(entry) : null)) {
+    if (newer(updatedAt, value))
+      updatedAt = value;
+  }
+  const inbox = collectPendingInboxRequests(entries);
+  const resolvedInbox = collectResolvedInboxRequests(entries);
+  for (const entry of [...inbox, ...resolvedInbox]) {
+    if (newer(updatedAt, entryUpdatedAt(entry)))
+      updatedAt = entryUpdatedAt(entry);
+  }
+  if (!started && !target && !task && !status && notes.length === 0 && inbox.length === 0 && resolvedInbox.length === 0 && !updatedAt)
+    return EMPTY_PROJECTION;
+  return { started, target, task, status, notes, inbox, resolvedInbox, updatedAt };
+}
+export {
+  projectWorkflowEntries,
+  projectCollabWorkflowMarker,
+  parseWorkflowTaskSelected,
+  parseWorkflowTargetSelected,
+  parseWorkflowStatusChanged,
+  parseWorkflowStarted,
+  parseWorkflowOperatorNote,
+  parseWorkflowInboxResolved,
+  parseWorkflowInboxRequested,
+  createWorkflowTaskSelected,
+  createWorkflowTargetSelected,
+  createWorkflowStatusChanged,
+  createWorkflowStarted,
+  createWorkflowOperatorNote,
+  createWorkflowInboxResolved,
+  createWorkflowInboxRequested,
+  collectResolvedInboxRequests,
+  collectPendingInboxRequests,
+  RIG_WORKFLOW_TASK_SELECTED,
+  RIG_WORKFLOW_TARGET_SELECTED,
+  RIG_WORKFLOW_STATUS_CHANGED,
+  RIG_WORKFLOW_STARTED,
+  RIG_WORKFLOW_OPERATOR_NOTE,
+  RIG_WORKFLOW_INBOX_RESOLVED,
+  RIG_WORKFLOW_INBOX_REQUESTED
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@h-rig/rig-extension",
+  "version": "0.0.6-alpha.91",
+  "type": "module",
+  "description": "Rig package",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/extension.d.ts",
+      "import": "./dist/src/extension.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "main": "./dist/src/extension.js",
+  "omp": {
+    "extensions": [
+      "./dist/src/extension.js"
+    ]
+  },
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.91",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.91",
+    "@rig/relay-registry": "0.0.6-alpha.91",
+    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.91",
+    "@oh-my-pi/pi-coding-agent": "16.0.4",
+    "@oh-my-pi/pi-tui": "16.0.4",
+    "effect": "4.0.0-beta.78"
+  }
+}