@tagma/sdk 0.1.7 → 0.1.9

package/src/completions/exit-code.ts

@@ -1,19 +1,19 @@
-import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
-
-export const ExitCodeCompletion: CompletionPlugin = {
-  name: 'exit_code',
-
-  async check(config: Record<string, unknown>, result: TaskResult, _ctx: CompletionContext): Promise<boolean> {
-    const expected = config.expect ?? 0;
-
-    if (typeof expected === 'number') {
-      return result.exitCode === expected;
-    }
-    if (Array.isArray(expected) && expected.every((v) => typeof v === 'number')) {
-      return expected.includes(result.exitCode);
-    }
-    throw new Error(
-      `exit_code completion: "expect" must be a number or number[], got ${typeof expected}`
-    );
-  },
-};
+import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
+
+export const ExitCodeCompletion: CompletionPlugin = {
+  name: 'exit_code',
+
+  async check(config: Record<string, unknown>, result: TaskResult, _ctx: CompletionContext): Promise<boolean> {
+    const expected = config.expect ?? 0;
+
+    if (typeof expected === 'number') {
+      return result.exitCode === expected;
+    }
+    if (Array.isArray(expected) && expected.every((v) => typeof v === 'number')) {
+      return expected.includes(result.exitCode);
+    }
+    throw new Error(
+      `exit_code completion: "expect" must be a number or number[], got ${typeof expected}`
+    );
+  },
+};

package/src/completions/file-exists.ts

@@ -1,39 +1,39 @@
-import { stat } from 'node:fs/promises';
-import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
-import { validatePath } from '../utils';
-
-type Kind = 'file' | 'dir' | 'any';
-
-export const FileExistsCompletion: CompletionPlugin = {
-  name: 'file_exists',
-
-  async check(config: Record<string, unknown>, _result: TaskResult, ctx: CompletionContext): Promise<boolean> {
-    const filePath = config.path as string;
-    if (!filePath) throw new Error('file_exists completion: "path" is required');
-
-    const safePath = validatePath(filePath, ctx.workDir);
-
-    const kind = (config.kind as Kind | undefined) ?? 'any';
-    if (kind !== 'file' && kind !== 'dir' && kind !== 'any') {
-      throw new Error(`file_exists completion: "kind" must be "file" | "dir" | "any", got "${kind}"`);
-    }
-
-    const minSize = config.min_size;
-    if (minSize != null && (typeof minSize !== 'number' || minSize < 0)) {
-      throw new Error(`file_exists completion: "min_size" must be a non-negative number`);
-    }
-
-    try {
-      const st = await stat(safePath);
-      if (kind === 'file' && !st.isFile()) return false;
-      if (kind === 'dir' && !st.isDirectory()) return false;
-      if (typeof minSize === 'number' && st.isFile() && st.size < minSize) return false;
-      return true;
-    } catch (err: unknown) {
-      const code = (err as NodeJS.ErrnoException).code;
-      if (code === 'ENOENT' || code === 'ENOTDIR') return false;
-      // Permission / IO errors should surface, not silently mean "missing"
-      throw err;
-    }
-  },
-};
+import { stat } from 'node:fs/promises';
+import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
+import { validatePath } from '../utils';
+
+type Kind = 'file' | 'dir' | 'any';
+
+export const FileExistsCompletion: CompletionPlugin = {
+  name: 'file_exists',
+
+  async check(config: Record<string, unknown>, _result: TaskResult, ctx: CompletionContext): Promise<boolean> {
+    const filePath = config.path as string;
+    if (!filePath) throw new Error('file_exists completion: "path" is required');
+
+    const safePath = validatePath(filePath, ctx.workDir);
+
+    const kind = (config.kind as Kind | undefined) ?? 'any';
+    if (kind !== 'file' && kind !== 'dir' && kind !== 'any') {
+      throw new Error(`file_exists completion: "kind" must be "file" | "dir" | "any", got "${kind}"`);
+    }
+
+    const minSize = config.min_size;
+    if (minSize != null && (typeof minSize !== 'number' || minSize < 0)) {
+      throw new Error(`file_exists completion: "min_size" must be a non-negative number`);
+    }
+
+    try {
+      const st = await stat(safePath);
+      if (kind === 'file' && !st.isFile()) return false;
+      if (kind === 'dir' && !st.isDirectory()) return false;
+      if (typeof minSize === 'number' && st.isFile() && st.size < minSize) return false;
+      return true;
+    } catch (err: unknown) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code === 'ENOENT' || code === 'ENOTDIR') return false;
+      // Permission / IO errors should surface, not silently mean "missing"
+      throw err;
+    }
+  },
+};

package/src/completions/output-check.ts

@@ -1,57 +1,57 @@
-import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
-import { shellArgs, parseDuration } from '../utils';
-
-const DEFAULT_TIMEOUT_MS = 30_000;
-
-export const OutputCheckCompletion: CompletionPlugin = {
-  name: 'output_check',
-
-  async check(config: Record<string, unknown>, result: TaskResult, ctx: CompletionContext): Promise<boolean> {
-    const checkCmd = config.check as string;
-    if (!checkCmd) throw new Error('output_check completion: "check" is required');
-
-    const timeoutMs = config.timeout != null
-      ? parseDuration(String(config.timeout))
-      : DEFAULT_TIMEOUT_MS;
-
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-
-    const proc = Bun.spawn(shellArgs(checkCmd) as string[], {
-      cwd: ctx.workDir,
-      stdin: 'pipe',
-      stdout: 'pipe',
-      stderr: 'pipe',
-      signal: controller.signal,
-    });
-
-    try {
-      if (proc.stdin) {
-        try {
-          proc.stdin.write(result.stdout);
-          await proc.stdin.end();
-        } catch (err: unknown) {
-          // EPIPE is expected when the check process exits before reading all of stdin
-          // (e.g. `grep -q` exits on first match). Anything else is a real failure.
-          const code = (err as NodeJS.ErrnoException)?.code;
-          if (code !== 'EPIPE') throw err;
-        }
-      }
-
-      const exitCode = await proc.exited;
-
-      if (exitCode !== 0) {
-        try {
-          const stderr = await new Response(proc.stderr).text();
-          if (stderr.trim()) {
-            console.warn(`[output_check] "${checkCmd}" exit=${exitCode}: ${stderr.trim()}`);
-          }
-        } catch { /* ignore stderr read failures */ }
-      }
-
-      return exitCode === 0;
-    } finally {
-      clearTimeout(timer);
-    }
-  },
-};
+import type { CompletionPlugin, CompletionContext, TaskResult } from '../types';
+import { shellArgs, parseDuration } from '../utils';
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+export const OutputCheckCompletion: CompletionPlugin = {
+  name: 'output_check',
+
+  async check(config: Record<string, unknown>, result: TaskResult, ctx: CompletionContext): Promise<boolean> {
+    const checkCmd = config.check as string;
+    if (!checkCmd) throw new Error('output_check completion: "check" is required');
+
+    const timeoutMs = config.timeout != null
+      ? parseDuration(String(config.timeout))
+      : DEFAULT_TIMEOUT_MS;
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+    const proc = Bun.spawn(shellArgs(checkCmd) as string[], {
+      cwd: ctx.workDir,
+      stdin: 'pipe',
+      stdout: 'pipe',
+      stderr: 'pipe',
+      signal: controller.signal,
+    });
+
+    try {
+      if (proc.stdin) {
+        try {
+          proc.stdin.write(result.stdout);
+          proc.stdin.end(); // no await — consistent with runner.ts; proc.exited handles sync
+        } catch (err: unknown) {
+          // EPIPE is expected when the check process exits before reading all of stdin
+          // (e.g. `grep -q` exits on first match). Anything else is a real failure.
+          const code = (err as NodeJS.ErrnoException)?.code;
+          if (code !== 'EPIPE') throw err;
+        }
+      }
+
+      // Consume stderr concurrently with waiting for exit to prevent pipe-buffer
+      // deadlock when check script emits more than ~64 KB of stderr output.
+      const [exitCode, stderr] = await Promise.all([
+        proc.exited,
+        new Response(proc.stderr).text(),
+      ]);
+
+      if (exitCode !== 0 && stderr.trim()) {
+        console.warn(`[output_check] "${checkCmd}" exit=${exitCode}: ${stderr.trim()}`);
+      }
+
+      return exitCode === 0;
+    } finally {
+      clearTimeout(timer);
+    }
+  },
+};

package/src/config-ops.ts

@@ -1,183 +1,239 @@
-// ═══ 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);
-}
+// ═══ 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 track = config.tracks[idx]!;
+  const withoutTrack = [...config.tracks.slice(0, idx), ...config.tracks.slice(idx + 1)];
+  const clamped = Math.max(0, Math.min(toIndex, withoutTrack.length));
+  const tracks = [...withoutTrack.slice(0, clamped), track, ...withoutTrack.slice(clamped)];
+  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.
+ *
+ * When `cleanRefs` is true, all `depends_on` and `continue_from` references to the
+ * removed task are also removed from every other task in the pipeline. This prevents
+ * validateRaw from reporting dangling-ref errors after the deletion.
+ */
+export function removeTask(
+  config: RawPipelineConfig,
+  trackId: string,
+  taskId: string,
+  cleanRefs = false,
+): RawPipelineConfig {
+  const withoutTask = {
+    ...config,
+    tracks: config.tracks.map(t => {
+      if (t.id !== trackId) return t;
+      return { ...t, tasks: t.tasks.filter(tk => tk.id !== taskId) };
+    }),
+  };
+
+  if (!cleanRefs) return withoutTask;
+
+  const qualId = `${trackId}.${taskId}`;
+
+  return {
+    ...withoutTask,
+    tracks: withoutTask.tracks.map(t => {
+      // Build the set of task IDs remaining in this track (the deleted task
+      // has already been removed from its own track in withoutTask).
+      const remainingIds = new Set(t.tasks.map(tk => tk.id));
+
+      // Resolve whether a ref in THIS track points to the deleted task:
+      //   - Fully-qualified ref ("trackId.taskId") — always points to the deleted task.
+      //   - Bare ref ("taskId") from the same track — always pointed to the deleted task
+      //     (same-track lookup takes priority, and the task was in this track).
+      //   - Bare ref from a different track — points to the deleted task only if this
+      //     track has no task with that same id (no local task to shadow it).
+      const isRemovedFrom = (ref: string): boolean => {
+        if (ref === qualId) return true;
+        if (ref === taskId) {
+          if (t.id === trackId) return true;            // same track — was pointing here
+          return !remainingIds.has(taskId);             // cross-track — only if no local override
+        }
+        return false;
+      };
+
+      return {
+        ...t,
+        tasks: t.tasks.map(tk => cleanTaskRefs(tk, isRemovedFrom)),
+      };
+    }),
+  };
+}
+
+function cleanTaskRefs(
+  task: RawTaskConfig,
+  isRemoved: (ref: string) => boolean,
+): RawTaskConfig {
+  const filteredDeps = task.depends_on?.filter(d => !isRemoved(d));
+  const dropContinueFrom = task.continue_from !== undefined && isRemoved(task.continue_from);
+
+  const depsUnchanged = filteredDeps === undefined || filteredDeps.length === task.depends_on!.length;
+  if (depsUnchanged && !dropContinueFrom) return task;
+
+  const { depends_on, continue_from, ...rest } = task;
+  return {
+    ...rest,
+    ...(filteredDeps !== undefined && filteredDeps.length > 0 ? { depends_on: filteredDeps } : {}),
+    ...(!dropContinueFrom && continue_from !== undefined ? { continue_from } : {}),
+  } as RawTaskConfig;
+}
+
+/**
+ * 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 task = t.tasks[idx]!;
+      const withoutTask = [...t.tasks.slice(0, idx), ...t.tasks.slice(idx + 1)];
+      const clamped = Math.max(0, Math.min(toIndex, withoutTask.length));
+      const tasks = [...withoutTask.slice(0, clamped), task, ...withoutTask.slice(clamped)];
+      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);
+}