@tagma/sdk 0.1.3 → 0.1.5

package/src/config-ops.ts

@@ -0,0 +1,183 @@
+// ═══ RawPipelineConfig CRUD Operations ═══
+//
+// Pure, immutable helper functions for building and editing pipeline configs
+// in a visual editor. None of these functions have runtime dependencies —
+// safe to import in any context (sidecar, renderer, tests).
+//
+// All operations return a new config object; inputs are never mutated.
+
+import type { RawPipelineConfig, RawTrackConfig, RawTaskConfig } from './types';
+
+// ── Pipeline ──
+
+/**
+ * Create a minimal empty pipeline config.
+ */
+export function createEmptyPipeline(name: string): RawPipelineConfig {
+  return { name, tracks: [] };
+}
+
+/**
+ * Update a top-level pipeline field (name, driver, timeout, etc.).
+ */
+export function setPipelineField(
+  config: RawPipelineConfig,
+  fields: Partial<Omit<RawPipelineConfig, 'tracks'>>,
+): RawPipelineConfig {
+  return { ...config, ...fields };
+}
+
+// ── Tracks ──
+
+/**
+ * Insert or replace a track by id. Appends if the id is new.
+ */
+export function upsertTrack(
+  config: RawPipelineConfig,
+  track: RawTrackConfig,
+): RawPipelineConfig {
+  const exists = config.tracks.some(t => t.id === track.id);
+  return {
+    ...config,
+    tracks: exists
+      ? config.tracks.map(t => (t.id === track.id ? track : t))
+      : [...config.tracks, track],
+  };
+}
+
+/**
+ * Remove a track by id. No-op if the id is not found.
+ */
+export function removeTrack(
+  config: RawPipelineConfig,
+  trackId: string,
+): RawPipelineConfig {
+  return { ...config, tracks: config.tracks.filter(t => t.id !== trackId) };
+}
+
+/**
+ * Move a track to a new index position (0-based).
+ * Clamps toIndex to valid bounds.
+ */
+export function moveTrack(
+  config: RawPipelineConfig,
+  trackId: string,
+  toIndex: number,
+): RawPipelineConfig {
+  const idx = config.tracks.findIndex(t => t.id === trackId);
+  if (idx === -1) return config;
+  const tracks = [...config.tracks];
+  const [track] = tracks.splice(idx, 1);
+  const clamped = Math.max(0, Math.min(toIndex, tracks.length));
+  tracks.splice(clamped, 0, track);
+  return { ...config, tracks };
+}
+
+/**
+ * Update fields on a single track (excluding tasks list, use upsertTask / removeTask for that).
+ */
+export function updateTrack(
+  config: RawPipelineConfig,
+  trackId: string,
+  fields: Partial<Omit<RawTrackConfig, 'id' | 'tasks'>>,
+): RawPipelineConfig {
+  return {
+    ...config,
+    tracks: config.tracks.map(t =>
+      t.id === trackId ? { ...t, ...fields } : t,
+    ),
+  };
+}
+
+// ── Tasks ──
+
+/**
+ * Insert or replace a task within a track, matched by task.id. Appends if new.
+ * No-op if the trackId is not found.
+ */
+export function upsertTask(
+  config: RawPipelineConfig,
+  trackId: string,
+  task: RawTaskConfig,
+): RawPipelineConfig {
+  return {
+    ...config,
+    tracks: config.tracks.map(t => {
+      if (t.id !== trackId) return t;
+      const exists = t.tasks.some(tk => tk.id === task.id);
+      return {
+        ...t,
+        tasks: exists
+          ? t.tasks.map(tk => (tk.id === task.id ? task : tk))
+          : [...t.tasks, task],
+      };
+    }),
+  };
+}
+
+/**
+ * Remove a task from a track. No-op if either id is not found.
+ */
+export function removeTask(
+  config: RawPipelineConfig,
+  trackId: string,
+  taskId: string,
+): RawPipelineConfig {
+  return {
+    ...config,
+    tracks: config.tracks.map(t => {
+      if (t.id !== trackId) return t;
+      return { ...t, tasks: t.tasks.filter(tk => tk.id !== taskId) };
+    }),
+  };
+}
+
+/**
+ * Reorder a task within its track.
+ * Clamps toIndex to valid bounds.
+ */
+export function moveTask(
+  config: RawPipelineConfig,
+  trackId: string,
+  taskId: string,
+  toIndex: number,
+): RawPipelineConfig {
+  return {
+    ...config,
+    tracks: config.tracks.map(t => {
+      if (t.id !== trackId) return t;
+      const idx = t.tasks.findIndex(tk => tk.id === taskId);
+      if (idx === -1) return t;
+      const tasks = [...t.tasks];
+      const [task] = tasks.splice(idx, 1);
+      const clamped = Math.max(0, Math.min(toIndex, tasks.length));
+      tasks.splice(clamped, 0, task);
+      return { ...t, tasks };
+    }),
+  };
+}
+
+/**
+ * Move a task from one track to another (appends to the target track).
+ * No-op if either trackId or taskId is not found.
+ */
+export function transferTask(
+  config: RawPipelineConfig,
+  fromTrackId: string,
+  taskId: string,
+  toTrackId: string,
+): RawPipelineConfig {
+  let task: RawTaskConfig | undefined;
+  const afterRemove = {
+    ...config,
+    tracks: config.tracks.map(t => {
+      if (t.id !== fromTrackId) return t;
+      const found = t.tasks.find(tk => tk.id === taskId);
+      if (!found) return t;
+      task = found;
+      return { ...t, tasks: t.tasks.filter(tk => tk.id !== taskId) };
+    }),
+  };
+  if (!task) return config;
+  return upsertTask(afterRemove, toTrackId, task);
+}

package/src/dag.ts

@@ -1,137 +1,137 @@
-import type { PipelineConfig, TaskConfig, TrackConfig } from './types';
-
-export interface DagNode {
-  readonly taskId: string;   // fully qualified: track_id.task_id or just task_id
-  readonly task: TaskConfig;
-  readonly track: TrackConfig;
-  readonly dependsOn: readonly string[];
-}
-
-export interface Dag {
-  readonly nodes: ReadonlyMap<string, DagNode>;
-  readonly sorted: readonly string[];   // topological order
-}
-
-// Build a global task ID: for cross-track refs we use "track_id.task_id"
-// Within a track, bare "task_id" is also valid
-function qualifyId(trackId: string, taskId: string): string {
-  return `${trackId}.${taskId}`;
-}
-
-export function buildDag(config: PipelineConfig): Dag {
-  const nodes = new Map<string, DagNode>();
-  // Map bare task IDs to qualified IDs (for resolving unqualified refs)
-  const bareToQualified = new Map<string, string>();
-
-  // 1. Register all nodes
-  for (const track of config.tracks) {
-    for (const task of track.tasks) {
-      const qid = qualifyId(track.id, task.id);
-
-      if (nodes.has(qid)) {
-        throw new Error(`Duplicate task ID: "${qid}"`);
-      }
-
-      // Track bare ID → qualified. If same bare ID in multiple tracks, mark ambiguous
-      if (bareToQualified.has(task.id)) {
-        bareToQualified.set(task.id, '__ambiguous__');
-      } else {
-        bareToQualified.set(task.id, qid);
-      }
-
-      nodes.set(qid, {
-        taskId: qid,
-        task,
-        track,
-        dependsOn: [],  // filled below
-      });
-    }
-  }
-
-  // Helper to resolve a dependency ref to a qualified ID
-  function resolveRef(ref: string, fromTrackId: string): string {
-    // Already qualified (contains dot)
-    if (ref.includes('.')) {
-      if (!nodes.has(ref)) {
-        throw new Error(`Task reference "${ref}" not found`);
-      }
-      return ref;
-    }
-    // Try within same track first
-    const sameTrack = qualifyId(fromTrackId, ref);
-    if (nodes.has(sameTrack)) return sameTrack;
-    // Try global bare lookup
-    const global = bareToQualified.get(ref);
-    if (global && global !== '__ambiguous__') return global;
-    if (global === '__ambiguous__') {
-      throw new Error(
-        `Ambiguous task reference "${ref}" exists in multiple tracks. ` +
-        `Use "track_id.task_id" format.`
-      );
-    }
-    throw new Error(`Task reference "${ref}" not found`);
-  }
-
-  // 2. Resolve depends_on and continue_from to qualified IDs
-  for (const track of config.tracks) {
-    for (const task of track.tasks) {
-      const qid = qualifyId(track.id, task.id);
-      const deps: string[] = [];
-
-      if (task.depends_on) {
-        for (const dep of task.depends_on) {
-          deps.push(resolveRef(dep, track.id));
-        }
-      }
-      if (task.continue_from) {
-        const resolved = resolveRef(task.continue_from, track.id);
-        if (!deps.includes(resolved)) {
-          deps.push(resolved); // continue_from implies dependency
-        }
-      }
-
-      // Replace node with resolved deps
-      const node = nodes.get(qid)!;
-      nodes.set(qid, { ...node, dependsOn: deps });
-    }
-  }
-
-  // 3. Topological sort + cycle detection (Kahn's algorithm)
-  const inDegree = new Map<string, number>();
-  const adjacency = new Map<string, string[]>(); // parent → children
-
-  for (const [id] of nodes) {
-    inDegree.set(id, 0);
-    adjacency.set(id, []);
-  }
-
-  for (const [id, node] of nodes) {
-    for (const dep of node.dependsOn) {
-      adjacency.get(dep)!.push(id);
-      inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
-    }
-  }
-
-  const queue: string[] = [];
-  for (const [id, degree] of inDegree) {
-    if (degree === 0) queue.push(id);
-  }
-
-  const sorted: string[] = [];
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    sorted.push(current);
-    for (const child of adjacency.get(current)!) {
-      const newDegree = inDegree.get(child)! - 1;
-      inDegree.set(child, newDegree);
-      if (newDegree === 0) queue.push(child);
-    }
-  }
-
-  if (sorted.length !== nodes.size) {
-    const remaining = [...nodes.keys()].filter(id => !sorted.includes(id));
-    throw new Error(`Circular dependency detected involving tasks: ${remaining.join(', ')}`);
-  }
-
-  return { nodes, sorted };
-}
+import type { PipelineConfig, TaskConfig, TrackConfig } from './types';
+
+export interface DagNode {
+  readonly taskId: string;   // fully qualified: track_id.task_id or just task_id
+  readonly task: TaskConfig;
+  readonly track: TrackConfig;
+  readonly dependsOn: readonly string[];
+}
+
+export interface Dag {
+  readonly nodes: ReadonlyMap<string, DagNode>;
+  readonly sorted: readonly string[];   // topological order
+}
+
+// Build a global task ID: for cross-track refs we use "track_id.task_id"
+// Within a track, bare "task_id" is also valid
+function qualifyId(trackId: string, taskId: string): string {
+  return `${trackId}.${taskId}`;
+}
+
+export function buildDag(config: PipelineConfig): Dag {
+  const nodes = new Map<string, DagNode>();
+  // Map bare task IDs to qualified IDs (for resolving unqualified refs)
+  const bareToQualified = new Map<string, string>();
+
+  // 1. Register all nodes
+  for (const track of config.tracks) {
+    for (const task of track.tasks) {
+      const qid = qualifyId(track.id, task.id);
+
+      if (nodes.has(qid)) {
+        throw new Error(`Duplicate task ID: "${qid}"`);
+      }
+
+      // Track bare ID → qualified. If same bare ID in multiple tracks, mark ambiguous
+      if (bareToQualified.has(task.id)) {
+        bareToQualified.set(task.id, '__ambiguous__');
+      } else {
+        bareToQualified.set(task.id, qid);
+      }
+
+      nodes.set(qid, {
+        taskId: qid,
+        task,
+        track,
+        dependsOn: [],  // filled below
+      });
+    }
+  }
+
+  // Helper to resolve a dependency ref to a qualified ID
+  function resolveRef(ref: string, fromTrackId: string): string {
+    // Already qualified (contains dot)
+    if (ref.includes('.')) {
+      if (!nodes.has(ref)) {
+        throw new Error(`Task reference "${ref}" not found`);
+      }
+      return ref;
+    }
+    // Try within same track first
+    const sameTrack = qualifyId(fromTrackId, ref);
+    if (nodes.has(sameTrack)) return sameTrack;
+    // Try global bare lookup
+    const global = bareToQualified.get(ref);
+    if (global && global !== '__ambiguous__') return global;
+    if (global === '__ambiguous__') {
+      throw new Error(
+        `Ambiguous task reference "${ref}" exists in multiple tracks. ` +
+        `Use "track_id.task_id" format.`
+      );
+    }
+    throw new Error(`Task reference "${ref}" not found`);
+  }
+
+  // 2. Resolve depends_on and continue_from to qualified IDs
+  for (const track of config.tracks) {
+    for (const task of track.tasks) {
+      const qid = qualifyId(track.id, task.id);
+      const deps: string[] = [];
+
+      if (task.depends_on) {
+        for (const dep of task.depends_on) {
+          deps.push(resolveRef(dep, track.id));
+        }
+      }
+      if (task.continue_from) {
+        const resolved = resolveRef(task.continue_from, track.id);
+        if (!deps.includes(resolved)) {
+          deps.push(resolved); // continue_from implies dependency
+        }
+      }
+
+      // Replace node with resolved deps
+      const node = nodes.get(qid)!;
+      nodes.set(qid, { ...node, dependsOn: deps });
+    }
+  }
+
+  // 3. Topological sort + cycle detection (Kahn's algorithm)
+  const inDegree = new Map<string, number>();
+  const adjacency = new Map<string, string[]>(); // parent → children
+
+  for (const [id] of nodes) {
+    inDegree.set(id, 0);
+    adjacency.set(id, []);
+  }
+
+  for (const [id, node] of nodes) {
+    for (const dep of node.dependsOn) {
+      adjacency.get(dep)!.push(id);
+      inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
+    }
+  }
+
+  const queue: string[] = [];
+  for (const [id, degree] of inDegree) {
+    if (degree === 0) queue.push(id);
+  }
+
+  const sorted: string[] = [];
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    sorted.push(current);
+    for (const child of adjacency.get(current)!) {
+      const newDegree = inDegree.get(child)! - 1;
+      inDegree.set(child, newDegree);
+      if (newDegree === 0) queue.push(child);
+    }
+  }
+
+  if (sorted.length !== nodes.size) {
+    const remaining = [...nodes.keys()].filter(id => !sorted.includes(id));
+    throw new Error(`Circular dependency detected involving tasks: ${remaining.join(', ')}`);
+  }
+
+  return { nodes, sorted };
+}