@tagma/sdk 0.7.4 → 0.7.6

package/src/core/run-context.ts

@@ -1,211 +0,0 @@
-import type {
-  AbortReason,
-  OnFailure,
-  Permissions,
-  PipelineConfig,
-  RunEventPayload,
-  TaskConfig,
-  TaskState,
-  TaskStatus,
-} from '../types';
-import type { Dag } from '../dag';
-import type { UpstreamBindingData } from '../ports';
-import {
-  executeHook,
-  buildTaskContext,
-  type PipelineInfo,
-  type TaskInfo,
-  type TrackInfo,
-} from '../hooks';
-import type { TagmaRuntime } from '../runtime';
-import { isTerminal } from './run-state';
-import { nowISO } from '../utils';
-
-function isPromptTaskConfig(
-  task: TaskConfig,
-): task is TaskConfig & { readonly prompt: string; readonly command?: undefined } {
-  return task.prompt !== undefined && task.command === undefined;
-}
-
-export interface RunContextOptions {
-  readonly runId: string;
-  readonly dag: Dag;
-  readonly config: PipelineConfig;
-  readonly workDir: string;
-  readonly pipelineInfo: PipelineInfo;
-  readonly onEvent?: (event: RunEventPayload) => void;
-  readonly runtime: TagmaRuntime;
-}
-
-/**
- * Per-run state container. Owns the maps and abort tracking that
- * `runPipeline` previously held as closure locals, plus the small
- * methods that read/write that state. Scheduler, dataflow, and
- * task-executor extractions in later phases pass `ctx` instead of
- * relying on closure capture.
- */
-export class RunContext {
-  readonly runId: string;
-  readonly dag: Dag;
-  readonly config: PipelineConfig;
-  readonly workDir: string;
-  readonly pipelineInfo: PipelineInfo;
-  readonly onEvent?: (event: RunEventPayload) => void;
-  readonly runtime: TagmaRuntime;
-
-  readonly states = new Map<string, TaskState>();
-  readonly sessionMap = new Map<string, string>();
-  readonly normalizedMap = new Map<string, string>();
-  readonly outputValuesMap = new Map<string, Readonly<Record<string, unknown>>>();
-  readonly bindingDataMap = new Map<string, UpstreamBindingData>();
-  readonly resolvedInputsMap = new Map<string, Readonly<Record<string, unknown>>>();
-  readonly directDownstreams: Map<string, string[]>;
-  readonly abortController = new AbortController();
-  abortReason: AbortReason | null = null;
-
-  constructor(options: RunContextOptions) {
-    this.runId = options.runId;
-    this.dag = options.dag;
-    this.config = options.config;
-    this.workDir = options.workDir;
-    this.pipelineInfo = options.pipelineInfo;
-    this.onEvent = options.onEvent;
-    this.runtime = options.runtime;
-
-    for (const [id, node] of this.dag.nodes) {
-      this.states.set(id, {
-        config: node.task,
-        trackConfig: node.track,
-        status: 'idle',
-        result: null,
-        startedAt: null,
-        finishedAt: null,
-      });
-    }
-
-    this.directDownstreams = new Map<string, string[]>();
-    for (const [id] of this.dag.nodes) this.directDownstreams.set(id, []);
-    for (const [id, node] of this.dag.nodes) {
-      for (const upstream of node.dependsOn) {
-        const list = this.directDownstreams.get(upstream);
-        if (list) list.push(id);
-      }
-    }
-  }
-
-  emit(event: RunEventPayload): void {
-    this.onEvent?.(event);
-  }
-
-  setTaskStatus(taskId: string, newStatus: TaskStatus): void {
-    const state = this.states.get(taskId)!;
-    // Terminal lock: once a task reaches a terminal state it must not be
-    // re-transitioned. This prevents stop_all from marking running tasks as
-    // skipped and then having their in-flight processTask promise overwrite
-    // that with success/failed, producing an invalid double transition.
-    if (isTerminal(state.status)) return;
-    state.status = newStatus;
-    const result = state.result;
-    const cfg = state.config;
-    this.emit({
-      type: 'task_update',
-      runId: this.runId,
-      taskId,
-      status: newStatus,
-      startedAt: state.startedAt ?? undefined,
-      finishedAt: state.finishedAt ?? undefined,
-      durationMs: result?.durationMs,
-      exitCode: result?.exitCode,
-      stdout: result?.stdout,
-      stderr: result?.stderr,
-      stdoutPath: result?.stdoutPath ?? null,
-      stderrPath: result?.stderrPath ?? null,
-      stdoutBytes: result?.stdoutBytes ?? null,
-      stderrBytes: result?.stderrBytes ?? null,
-      sessionId: result?.sessionId ?? null,
-      normalizedOutput: result?.normalizedOutput ?? null,
-      inputs: this.resolvedInputsMap.get(taskId) ?? null,
-      outputs: this.outputValuesMap.get(taskId) ?? null,
-      resolvedDriver: cfg.driver ?? null,
-      resolvedModel: cfg.model ?? null,
-      resolvedPermissions: (cfg.permissions as Permissions | undefined) ?? null,
-    });
-  }
-
-  getOnFailure(taskId: string): OnFailure {
-    return this.dag.nodes.get(taskId)?.track.on_failure ?? 'skip_downstream';
-  }
-
-  isDependencySatisfied(depId: string): 'satisfied' | 'unsatisfied' | 'skip' {
-    const depState = this.states.get(depId);
-    if (!depState) return 'skip';
-    switch (depState.status) {
-      case 'success':
-        return 'satisfied';
-      case 'skipped':
-        return 'skip';
-      case 'failed':
-      case 'timeout':
-      case 'blocked':
-        return this.getOnFailure(depId) === 'ignore' ? 'satisfied' : 'skip';
-      default:
-        return 'unsatisfied';
-    }
-  }
-
-  /**
-   * H3: stop_all marks every still-waiting task across every track as
-   * skipped and aborts in-flight tasks via the shared signal. The
-   * terminal lock in setTaskStatus prevents any later re-transition
-   * should a completed running task try to overwrite the skipped state.
-   */
-  applyStopAll(): void {
-    if (this.abortReason === null) this.abortReason = 'stop_all';
-    this.abortController.abort();
-    for (const [id, state] of this.states) {
-      if (state.status === 'waiting') {
-        state.finishedAt = nowISO();
-        this.setTaskStatus(id, 'skipped');
-      }
-    }
-  }
-
-  buildTaskInfoObj(taskId: string): TaskInfo {
-    const state = this.states.get(taskId)!;
-    return {
-      id: taskId,
-      name: state.config.name,
-      type: isPromptTaskConfig(state.config) ? 'ai' : 'command',
-      status: state.status,
-      exit_code: state.result?.exitCode ?? null,
-      duration_ms: state.result?.durationMs ?? null,
-      stderr_path: state.result?.stderrPath ?? null,
-      session_id: state.result?.sessionId ?? null,
-      started_at: state.startedAt,
-      finished_at: state.finishedAt,
-    };
-  }
-
-  trackInfoOf(taskId: string): TrackInfo {
-    const node = this.dag.nodes.get(taskId)!;
-    return { id: node.track.id, name: node.track.name };
-  }
-
-  async fireHook(
-    taskId: string,
-    event: 'task_success' | 'task_failure',
-  ): Promise<void> {
-    await executeHook(
-      this.config.hooks,
-      event,
-      buildTaskContext(
-        event,
-        this.pipelineInfo,
-        this.trackInfoOf(taskId),
-        this.buildTaskInfoObj(taskId),
-      ),
-      this.workDir,
-      this.abortController.signal,
-    );
-  }
-}

package/src/core/run-state.test.ts

@@ -1,98 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  isTerminal,
-  freezeStates,
-  summarizeStates,
-  toRunTaskState,
-} from './run-state';
-import type { TaskState, TaskStatus } from '../types';
-
-describe('isTerminal', () => {
-  test('returns true for terminal statuses', () => {
-    expect(isTerminal('success')).toBe(true);
-    expect(isTerminal('failed')).toBe(true);
-    expect(isTerminal('timeout')).toBe(true);
-    expect(isTerminal('skipped')).toBe(true);
-    expect(isTerminal('blocked')).toBe(true);
-  });
-  test('returns false for non-terminal statuses', () => {
-    expect(isTerminal('idle')).toBe(false);
-    expect(isTerminal('waiting')).toBe(false);
-    expect(isTerminal('running')).toBe(false);
-  });
-});
-
-function makeState(status: TaskStatus, opts: Partial<TaskState> = {}): TaskState {
-  return {
-    config: { id: 't', name: 't' } as TaskState['config'],
-    trackConfig: { id: 'tr', name: 'tr', tasks: [] } as TaskState['trackConfig'],
-    status,
-    result: null,
-    startedAt: null,
-    finishedAt: null,
-    ...opts,
-  };
-}
-
-describe('freezeStates', () => {
-  test('produces a deep copy that survives source mutation', () => {
-    const src = new Map<string, TaskState>();
-    src.set('a', makeState('success'));
-    const frozen = freezeStates(src);
-    src.get('a')!.status = 'failed';
-    expect(frozen.get('a')!.status).toBe('success');
-  });
-
-  test('copies result object so mutation does not bleed through', () => {
-    const src = new Map<string, TaskState>();
-    src.set('a', makeState('success', {
-      result: {
-        exitCode: 0,
-        stdout: 'x',
-        stderr: '',
-        stdoutPath: null,
-        stderrPath: null,
-        durationMs: 1,
-        sessionId: null,
-        normalizedOutput: null,
-        outputs: null,
-      } as TaskState['result'],
-    }));
-    const frozen = freezeStates(src);
-    src.get('a')!.result!.stdout = 'mutated';
-    expect(frozen.get('a')!.result!.stdout).toBe('x');
-  });
-});
-
-describe('summarizeStates', () => {
-  test('counts each terminal status into its own bucket', () => {
-    const m = new Map<string, TaskState>();
-    m.set('a', makeState('success'));
-    m.set('b', makeState('failed'));
-    m.set('c', makeState('skipped'));
-    m.set('d', makeState('timeout'));
-    m.set('e', makeState('blocked'));
-    m.set('f', makeState('running'));
-    expect(summarizeStates(m)).toEqual({
-      total: 6,
-      success: 1,
-      failed: 1,
-      skipped: 1,
-      timeout: 1,
-      blocked: 1,
-    });
-  });
-});
-
-describe('toRunTaskState', () => {
-  test('projects null result onto wire shape with empty stdout/stderr', () => {
-    const wire = toRunTaskState('t1', 'trk', 'Task 1', makeState('idle'));
-    expect(wire.taskId).toBe('t1');
-    expect(wire.trackId).toBe('trk');
-    expect(wire.status).toBe('idle');
-    expect(wire.stdout).toBe('');
-    expect(wire.stderr).toBe('');
-    expect(wire.exitCode).toBeNull();
-    expect(wire.logs).toEqual([]);
-  });
-});

package/src/core/run-state.ts

@@ -1,122 +0,0 @@
-import type {
-  TaskState,
-  TaskStatus,
-  RunTaskState,
-  Permissions,
-} from '../types';
-
-export function isTerminal(status: TaskStatus): boolean {
-  return (
-    status === 'success' ||
-    status === 'failed' ||
-    status === 'timeout' ||
-    status === 'skipped' ||
-    status === 'blocked'
-  );
-}
-
-/** Return a deep-copied, caller-safe snapshot of the states map. */
-export function freezeStates(
-  states: Map<string, TaskState>,
-): ReadonlyMap<string, TaskState> {
-  const copy = new Map<string, TaskState>();
-  for (const [id, s] of states) {
-    copy.set(id, {
-      config: { ...s.config },
-      trackConfig: { ...s.trackConfig },
-      status: s.status,
-      result: s.result ? { ...s.result } : null,
-      startedAt: s.startedAt,
-      finishedAt: s.finishedAt,
-    });
-  }
-  return copy;
-}
-
-export interface RunSummary {
-  total: number;
-  success: number;
-  failed: number;
-  skipped: number;
-  timeout: number;
-  blocked: number;
-}
-
-/**
- * Tally terminal task counts. Idle/waiting/running tasks are counted in
- * `total` but not in any per-status bucket — same semantics as the
- * original engine.ts summary loop.
- */
-export function summarizeStates(
-  states: ReadonlyMap<string, TaskState>,
-): RunSummary {
-  const summary: RunSummary = {
-    total: 0,
-    success: 0,
-    failed: 0,
-    skipped: 0,
-    timeout: 0,
-    blocked: 0,
-  };
-  for (const [, state] of states) {
-    summary.total++;
-    switch (state.status) {
-      case 'success':
-        summary.success++;
-        break;
-      case 'failed':
-        summary.failed++;
-        break;
-      case 'skipped':
-        summary.skipped++;
-        break;
-      case 'timeout':
-        summary.timeout++;
-        break;
-      case 'blocked':
-        summary.blocked++;
-        break;
-    }
-  }
-  return summary;
-}
-
-/**
- * Project the engine's internal TaskState onto the wire RunTaskState
- * shape. `logs` / `totalLogCount` default to empty — they are populated
- * on the server side from streamed `task_log` events, not from state.
- */
-export function toRunTaskState(
-  taskId: string,
-  trackId: string,
-  taskName: string,
-  state: TaskState,
-): RunTaskState {
-  const result = state.result;
-  const cfg = state.config;
-  return {
-    taskId,
-    trackId,
-    taskName,
-    status: state.status,
-    startedAt: state.startedAt,
-    finishedAt: state.finishedAt,
-    durationMs: result?.durationMs ?? null,
-    exitCode: result?.exitCode ?? null,
-    stdout: result?.stdout ?? '',
-    stderr: result?.stderr ?? '',
-    stdoutPath: result?.stdoutPath ?? null,
-    stderrPath: result?.stderrPath ?? null,
-    stdoutBytes: result?.stdoutBytes ?? null,
-    stderrBytes: result?.stderrBytes ?? null,
-    sessionId: result?.sessionId ?? null,
-    normalizedOutput: result?.normalizedOutput ?? null,
-    resolvedDriver: cfg.driver ?? null,
-    resolvedModel: cfg.model ?? null,
-    resolvedPermissions: (cfg.permissions as Permissions | undefined) ?? null,
-    outputs: result?.outputs ?? null,
-    inputs: null,
-    logs: [],
-    totalLogCount: 0,
-  };
-}

package/src/core/scheduler.test.ts

@@ -1,83 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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');
-  }
-}