@tagma/sdk 0.6.12 → 0.7.0

package/src/core/scheduler.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from 'bun:test';
+import { buildDag } from '../dag';
+import type { PipelineConfig } from '../types';
+import { RunContext } from './run-context';
+import {
+  allTasksTerminal,
+  findLaunchableTasks,
+  skipNonTerminalTasks,
+} from './scheduler';
+
+function makeContext(config: PipelineConfig): RunContext {
+  return new RunContext({
+    runId: 'run_scheduler',
+    dag: buildDag(config),
+    config,
+    workDir: '/tmp/wd',
+    pipelineInfo: {
+      name: config.name,
+      run_id: 'run_scheduler',
+      started_at: '2026-04-26T00:00:00Z',
+    },
+  });
+}
+
+const chainConfig: PipelineConfig = {
+  name: 'p',
+  tracks: [
+    {
+      id: 't',
+      name: 'T',
+      tasks: [
+        { id: 'a', name: 'A', command: 'echo a' },
+        { id: 'b', name: 'B', command: 'echo b', depends_on: ['a'] },
+        { id: 'c', name: 'C', command: 'echo c' },
+      ],
+    },
+  ],
+};
+
+describe('findLaunchableTasks', () => {
+  test('returns waiting roots that are not already running', () => {
+    const ctx = makeContext(chainConfig);
+    for (const state of ctx.states.values()) state.status = 'waiting';
+
+    expect(findLaunchableTasks(ctx, new Set())).toEqual(['t.a', 't.c']);
+    expect(findLaunchableTasks(ctx, new Set(['t.a']))).toEqual(['t.c']);
+  });
+
+  test('returns dependents only after dependencies are terminal', () => {
+    const ctx = makeContext(chainConfig);
+    for (const state of ctx.states.values()) state.status = 'waiting';
+
+    expect(findLaunchableTasks(ctx, new Set())).not.toContain('t.b');
+    ctx.states.get('t.a')!.status = 'success';
+    expect(findLaunchableTasks(ctx, new Set())).toContain('t.b');
+  });
+});
+
+describe('allTasksTerminal', () => {
+  test('returns true only when every task is terminal', () => {
+    const ctx = makeContext(chainConfig);
+    for (const state of ctx.states.values()) state.status = 'success';
+    expect(allTasksTerminal(ctx)).toBe(true);
+    ctx.states.get('t.b')!.status = 'waiting';
+    expect(allTasksTerminal(ctx)).toBe(false);
+  });
+});
+
+describe('skipNonTerminalTasks', () => {
+  test('marks every non-terminal task as skipped and leaves terminal tasks alone', () => {
+    const ctx = makeContext(chainConfig);
+    ctx.states.get('t.a')!.status = 'success';
+    ctx.states.get('t.b')!.status = 'waiting';
+    ctx.states.get('t.c')!.status = 'running';
+
+    skipNonTerminalTasks(ctx, '2026-04-26T01:00:00Z');
+
+    expect(ctx.states.get('t.a')!.status).toBe('success');
+    expect(ctx.states.get('t.b')!.status).toBe('skipped');
+    expect(ctx.states.get('t.b')!.finishedAt).toBe('2026-04-26T01:00:00Z');
+    expect(ctx.states.get('t.c')!.status).toBe('skipped');
+  });
+});

package/src/core/scheduler.ts

@@ -0,0 +1,42 @@
+import type { RunContext } from './run-context';
+import { isTerminal } from './run-state';
+import { nowISO } from '../utils';
+
+/**
+ * Return waiting tasks whose dependency states are terminal and which are not
+ * already in flight. The caller owns actually launching them.
+ */
+export function findLaunchableTasks(
+  ctx: RunContext,
+  runningTaskIds: ReadonlySet<string>,
+): string[] {
+  const launchable: string[] = [];
+  for (const [id, state] of ctx.states) {
+    if (state.status !== 'waiting' || runningTaskIds.has(id)) continue;
+    const node = ctx.dag.nodes.get(id)!;
+    const allDepsTerminal =
+      node.dependsOn.length === 0 ||
+      node.dependsOn.every((depId) => isTerminal(ctx.states.get(depId)!.status));
+    if (allDepsTerminal) launchable.push(id);
+  }
+  return launchable;
+}
+
+export function allTasksTerminal(ctx: RunContext): boolean {
+  return [...ctx.states.values()].every((state) => isTerminal(state.status));
+}
+
+/**
+ * Abort cleanup helper: after in-flight tasks settle, any remaining
+ * non-terminal tasks are waiting/idle tasks that were never started.
+ */
+export function skipNonTerminalTasks(
+  ctx: RunContext,
+  finishedAt = nowISO(),
+): void {
+  for (const [id, state] of ctx.states) {
+    if (isTerminal(state.status)) continue;
+    state.finishedAt = finishedAt;
+    ctx.setTaskStatus(id, 'skipped');
+  }
+}