@kbediako/codex-orchestrator 0.1.38 → 0.2.1

package/dist/orchestrator/src/cli/control/providerLinearWorkflowStates.js

@@ -0,0 +1,115 @@
+const ACTIVE_PROVIDER_LINEAR_WORKFLOW_STATES = new Set([
+    'todo',
+    'in progress',
+    'merging',
+    'rework'
+]);
+const TODO_EQUIVALENT_PROVIDER_LINEAR_WORKFLOW_STATES = new Set(['todo', 'ready']);
+const HANDOFF_PROVIDER_LINEAR_WORKFLOW_STATES = new Set(['human review', 'in review']);
+const TERMINAL_PROVIDER_LINEAR_WORKFLOW_STATES = new Set([
+    'closed',
+    'cancelled',
+    'canceled',
+    'duplicate',
+    'done'
+]);
+const TERMINAL_PROVIDER_LINEAR_WORKFLOW_STATE_TYPES = new Set([
+    'completed',
+    'cancelled',
+    'canceled'
+]);
+export function normalizeProviderLinearWorkflowState(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+}
+export function classifyProviderLinearWorkflowState(input) {
+    const normalizedState = normalizeProviderLinearWorkflowState(input.state);
+    const normalizedStateType = normalizeProviderLinearWorkflowState(input.state_type);
+    const isTodo = normalizedState !== null &&
+        TODO_EQUIVALENT_PROVIDER_LINEAR_WORKFLOW_STATES.has(normalizedState);
+    const isHandoff = normalizedState !== null && HANDOFF_PROVIDER_LINEAR_WORKFLOW_STATES.has(normalizedState);
+    const isTerminal = (normalizedState !== null &&
+        TERMINAL_PROVIDER_LINEAR_WORKFLOW_STATES.has(normalizedState)) ||
+        (normalizedStateType !== null &&
+            TERMINAL_PROVIDER_LINEAR_WORKFLOW_STATE_TYPES.has(normalizedStateType));
+    const isActive = !isHandoff &&
+        !isTerminal &&
+        normalizedState !== null &&
+        (ACTIVE_PROVIDER_LINEAR_WORKFLOW_STATES.has(normalizedState) ||
+            TODO_EQUIVALENT_PROVIDER_LINEAR_WORKFLOW_STATES.has(normalizedState));
+    return {
+        normalizedState,
+        normalizedStateType,
+        isTodo,
+        isHandoff,
+        isTerminal,
+        isActive
+    };
+}
+export function isProviderLinearTerminalReopenTransition(input) {
+    const current = classifyProviderLinearWorkflowState(input.current);
+    const target = classifyProviderLinearWorkflowState(input.target);
+    return current.isTerminal && !target.isTerminal;
+}
+export function providerLinearTodoBlockedByNonTerminal(blockers) {
+    return (blockers ?? []).some((blocker) => {
+        const normalizedBlockerStateType = normalizeProviderLinearWorkflowState(blocker.state_type);
+        if (normalizedBlockerStateType !== null) {
+            return !TERMINAL_PROVIDER_LINEAR_WORKFLOW_STATE_TYPES.has(normalizedBlockerStateType);
+        }
+        const normalizedBlockerState = normalizeProviderLinearWorkflowState(blocker.state);
+        return (normalizedBlockerState === null ||
+            !TERMINAL_PROVIDER_LINEAR_WORKFLOW_STATES.has(normalizedBlockerState));
+    });
+}
+export function isProviderLinearTrackedIssueMutable(issue) {
+    return !issue.archived_at && issue.trashed !== true;
+}
+function isProviderLinearWorkflowStateExecutionEligible(input) {
+    if (!isProviderLinearTrackedIssueMutable(input.issue)) {
+        return false;
+    }
+    if (!input.workflowState.isActive) {
+        return false;
+    }
+    if (input.workflowState.isTodo &&
+        providerLinearTodoBlockedByNonTerminal(input.issue.blocked_by)) {
+        return false;
+    }
+    return true;
+}
+export function classifyProviderLinearWorkerLifecycle(issue) {
+    const workflowState = classifyProviderLinearWorkflowState(issue);
+    const isExecutionEligible = isProviderLinearWorkflowStateExecutionEligible({
+        workflowState,
+        issue
+    });
+    if (isExecutionEligible) {
+        return {
+            workflowState,
+            isExecutionEligible,
+            phase: 'active',
+            terminalReason: null
+        };
+    }
+    if (workflowState.isHandoff) {
+        return {
+            workflowState,
+            isExecutionEligible,
+            phase: 'review_handoff',
+            terminalReason: 'issue_review_handoff'
+        };
+    }
+    return {
+        workflowState,
+        isExecutionEligible,
+        phase: 'inactive',
+        terminalReason: 'issue_inactive'
+    };
+}
+export function isProviderLinearTrackedIssueEligibleForExecution(issue) {
+    return classifyProviderLinearWorkerLifecycle(issue).isExecutionEligible;
+}