@tagma/sdk 0.7.4 → 0.7.6

package/src/engine-ports.test.ts

@@ -1,210 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { bootstrapBuiltins } from './bootstrap';
-import { runPipeline, type RunEventPayload } from './engine';
-import { PluginRegistry } from './registry';
-import type { PipelineConfig, TaskConfig, TagmaRuntime, TaskResult, TaskStatus } from './types';
-
-const PERMS = { read: true, write: false, execute: false };
-
-function freshRegistry(): PluginRegistry {
-  const reg = new PluginRegistry();
-  bootstrapBuiltins(reg);
-  return reg;
-}
-
-function makeDir(): string {
-  return mkdtempSync(join(tmpdir(), 'tagma-bindings-'));
-}
-
-function task(overrides: Partial<TaskConfig> & { id: string }): TaskConfig {
-  return {
-    name: overrides.id,
-    permissions: PERMS,
-    driver: 'opencode',
-    ...overrides,
-  };
-}
-
-function pipeline(tasks: TaskConfig[]): PipelineConfig {
-  return {
-    name: 'bindings-test',
-    tracks: [
-      {
-        id: 't',
-        name: 'T',
-        driver: 'opencode',
-        permissions: PERMS,
-        on_failure: 'skip_downstream',
-        tasks,
-      },
-    ],
-  };
-}
-
-function taskResult(stdout: string): TaskResult {
-  return {
-    exitCode: 0,
-    stdout,
-    stderr: '',
-    stdoutPath: null,
-    stderrPath: null,
-    stdoutBytes: stdout.length,
-    stderrBytes: 0,
-    durationMs: 1,
-    sessionId: null,
-    normalizedOutput: null,
-    failureKind: null,
-  };
-}
-
-function fakeRuntime(commandStdout: Record<string, string>): TagmaRuntime {
-  return {
-    async runCommand(command) {
-      for (const [prefix, stdout] of Object.entries(commandStdout)) {
-        if (command.startsWith(prefix)) return taskResult(stdout);
-      }
-      return taskResult('Shanghai|42\n');
-    },
-    async runSpawn() {
-      throw new Error('runSpawn should not be called');
-    },
-    async ensureDir() {
-      /* no-op */
-    },
-    async fileExists() {
-      return false;
-    },
-    async *watch() {
-      /* no-op */
-    },
-    logStore: {
-      openRunLog({ runId }) {
-        return {
-          path: `mem://${runId}/pipeline.log`,
-          dir: `mem://${runId}`,
-          append() {
-            /* memory sink */
-          },
-          close() {
-            /* memory sink */
-          },
-        };
-      },
-      taskOutputPath({ runId, taskId, stream }) {
-        return `mem://${runId}/${taskId}.${stream}`;
-      },
-      logsDir() {
-        return 'mem://logs';
-      },
-    },
-    now: () => new Date('2026-04-26T00:00:00.000Z'),
-    sleep: () => Promise.resolve(),
-  };
-}
-
-async function run(config: PipelineConfig, workDir: string, runtime: TagmaRuntime) {
-  const events: RunEventPayload[] = [];
-  const result = await runPipeline(config, workDir, {
-    registry: freshRegistry(),
-    runtime,
-    skipPluginLoading: true,
-    onEvent: (e) => events.push(e),
-  });
-  return { events, success: result.success };
-}
-
-function finalUpdateFor(events: RunEventPayload[], qid: string): RunEventPayload | undefined {
-  let last: RunEventPayload | undefined;
-  for (const ev of events) {
-    if (ev.type === 'task_update' && ev.taskId === qid) last = ev;
-  }
-  return last;
-}
-
-function finalStatusFrom(events: RunEventPayload[], qid: string): TaskStatus | undefined {
-  const last = finalUpdateFor(events, qid);
-  return last && last.type === 'task_update' ? last.status : undefined;
-}
-
-describe('engine — unified inputs and outputs', () => {
-  test('typed outputs feed typed inputs and command placeholders', async () => {
-    const dir = makeDir();
-    try {
-      const runtime = fakeRuntime({ 'emit-valid': '{"id":"42","city":"Shanghai"}\n' });
-      const config = pipeline([
-        task({
-          id: 'up',
-          command: 'emit-valid',
-          outputs: { id: { type: 'number' }, city: { type: 'string' } },
-        }),
-        task({
-          id: 'down',
-          depends_on: ['up'],
-          command: 'echo-down "{{inputs.city}}" "{{inputs.id}}"',
-          inputs: {
-            city: { from: 't.up.outputs.city', type: 'string', required: true },
-            id: { from: 't.up.outputs.id', type: 'number', required: true },
-          },
-        }),
-      ]);
-
-      const { events, success } = await run(config, dir, runtime);
-      expect(success).toBe(true);
-      expect(finalUpdateFor(events, 't.up')?.outputs).toEqual({ id: 42, city: 'Shanghai' });
-      expect(finalUpdateFor(events, 't.down')?.inputs).toEqual({ city: 'Shanghai', id: 42 });
-      expect(finalUpdateFor(events, 't.down')?.stdout).toContain('Shanghai|42');
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test('missing required unified input blocks without spawning downstream', async () => {
-    const dir = makeDir();
-    try {
-      const runtime = fakeRuntime({ 'emit-missing': '{"other":"x"}\n' });
-      const config = pipeline([
-        task({ id: 'up', command: 'emit-missing', outputs: { city: { type: 'string' } } }),
-        task({
-          id: 'down',
-          depends_on: ['up'],
-          command: 'echo-down "{{inputs.city}}"',
-          inputs: { city: { from: 't.up.outputs.city', type: 'string', required: true } },
-        }),
-      ]);
-
-      const { events, success } = await run(config, dir, runtime);
-      expect(success).toBe(false);
-      expect(finalStatusFrom(events, 't.up')).toBe('success');
-      expect(finalStatusFrom(events, 't.down')).toBe('blocked');
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test('typed output coercion diagnostics leave missing downstream input', async () => {
-    const dir = makeDir();
-    try {
-      const runtime = fakeRuntime({ 'emit-bad': '{"id":"not-a-number"}\n' });
-      const config = pipeline([
-        task({ id: 'up', command: 'emit-bad', outputs: { id: { type: 'number' } } }),
-        task({
-          id: 'down',
-          depends_on: ['up'],
-          command: 'echo-down "{{inputs.id}}"',
-          inputs: { id: { from: 't.up.outputs.id', type: 'number', required: true } },
-        }),
-      ]);
-
-      const { events, success } = await run(config, dir, runtime);
-      expect(success).toBe(false);
-      expect(finalStatusFrom(events, 't.up')).toBe('success');
-      expect(finalUpdateFor(events, 't.up')?.stderr).toContain('expected number');
-      expect(finalStatusFrom(events, 't.down')).toBe('blocked');
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

package/src/engine-task-type.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { runPipeline, type RunEventPayload } from './engine';
-import { PluginRegistry } from './registry';
-import type { PipelineConfig } from './types';
-
-function makeDir(): string {
-  return mkdtempSync(join(tmpdir(), 'tagma-task-type-'));
-}
-
-describe('engine task type detection', () => {
-  test('empty command is still a command task and does not require a driver', async () => {
-    const dir = makeDir();
-    const previousShell = process.env.PIPELINE_SHELL;
-    process.env.PIPELINE_SHELL = 'cmd';
-    try {
-      const events: RunEventPayload[] = [];
-      const config: PipelineConfig = {
-        name: 'empty-command',
-        tracks: [
-          {
-            id: 't',
-            name: 'T',
-            tasks: [{ id: 'cmd', name: 'cmd', command: '' }],
-          },
-        ],
-      };
-
-      const result = await runPipeline(config, dir, {
-        registry: new PluginRegistry(),
-        skipPluginLoading: true,
-        onEvent: (event) => events.push(event),
-      });
-
-      expect(result.success).toBe(true);
-      expect(events.some((event) => event.type === 'run_start')).toBe(true);
-      const final = events.findLast(
-        (event) => event.type === 'task_update' && event.taskId === 't.cmd',
-      );
-      expect(final?.type).toBe('task_update');
-      if (final?.type === 'task_update') {
-        expect(final.status).toBe('success');
-        expect(final.resolvedDriver).toBeNull();
-      }
-    } finally {
-      if (previousShell === undefined) {
-        delete process.env.PIPELINE_SHELL;
-      } else {
-        process.env.PIPELINE_SHELL = previousShell;
-      }
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

package/src/engine.ts

@@ -1,32 +0,0 @@
-import {
-  runPipeline as runCorePipeline,
-  TriggerBlockedError,
-  TriggerTimeoutError,
-  type EngineResult,
-  type RunEventPayload,
-  type RunPipelineOptions as CoreRunPipelineOptions,
-} from '@tagma/core';
-import { bunRuntime } from '@tagma/runtime-bun';
-import type { PipelineConfig, TagmaRuntime } from './types';
-
-export { TriggerBlockedError, TriggerTimeoutError };
-export type { EngineResult, RunEventPayload };
-
-export interface RunPipelineOptions extends Omit<CoreRunPipelineOptions, 'runtime'> {
-  /**
-   * Runtime implementation for command and driver process execution.
-   * Defaults to the SDK's Bun runtime.
-   */
-  readonly runtime?: TagmaRuntime;
-}
-
-export function runPipeline(
-  config: PipelineConfig,
-  workDir: string,
-  options: RunPipelineOptions,
-): Promise<EngineResult> {
-  return runCorePipeline(config, workDir, {
-    ...options,
-    runtime: options.runtime ?? bunRuntime(),
-  });
-}

package/src/hooks.ts

@@ -1,193 +0,0 @@
-import type { HooksConfig, HookCommand, AbortReason } from './types';
-import { shellArgs } from './utils';
-
-type HookEvent =
-  | 'pipeline_start'
-  | 'task_start'
-  | 'task_success'
-  | 'task_failure'
-  | 'pipeline_complete'
-  | 'pipeline_error';
-
-const GATE_HOOKS: ReadonlySet<HookEvent> = new Set(['pipeline_start', 'task_start']);
-
-export interface HookResult {
-  readonly allowed: boolean; // for gate hooks: true = proceed, false = block
-  readonly exitCode: number;
-}
-
-function normalizeCommands(cmd: HookCommand | undefined): readonly string[] {
-  if (!cmd) return [];
-  if (typeof cmd === 'string') return [cmd];
-  return cmd;
-}
-
-const DEFAULT_HOOK_TIMEOUT_MS = 30_000;
-
-async function runSingleHook(
-  command: string,
-  context: unknown,
-  cwd?: string,
-  signal?: AbortSignal,
-  timeoutMs: number = DEFAULT_HOOK_TIMEOUT_MS,
-): Promise<number> {
-  const jsonInput = JSON.stringify(context, null, 2);
-
-  const controller = new AbortController();
-  const timer = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
-
-  // Wire pipeline abort signal into hook process
-  const onAbort = () => controller.abort();
-  if (signal) {
-    if (signal.aborted) {
-      controller.abort();
-    } else {
-      signal.addEventListener('abort', onAbort, { once: true });
-    }
-  }
-
-  try {
-    const proc = Bun.spawn(shellArgs(command) as string[], {
-      stdin: 'pipe',
-      stdout: 'pipe',
-      stderr: 'pipe',
-      signal: controller.signal,
-      ...(cwd ? { cwd } : {}),
-    });
-
-    if (proc.stdin) {
-      try {
-        proc.stdin.write(jsonInput);
-        proc.stdin.end();
-      } catch {
-        // Process may exit before reading stdin (e.g. `exit 1`), ignore EPIPE
-      }
-    }
-
-    // Consume stdout and stderr concurrently with waiting for exit.
-    // Sequential reads after proc.exited risk a pipe-buffer deadlock when
-    // hook output exceeds the ~64 KB kernel buffer.
-    const [exitCode, stdout, stderr] = await Promise.all([
-      proc.exited,
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ]);
-
-    if (stdout.trim()) {
-      console.warn(`[hook: ${command}] stdout: ${stdout.trim()}`);
-    }
-    if (stderr.trim()) {
-      console.error(`[hook: ${command}] stderr: ${stderr.trim()}`);
-    }
-
-    return exitCode;
-  } catch (err) {
-    console.error(
-      `[hook: ${command}] spawn error: ${err instanceof Error ? err.message : String(err)}`,
-    );
-    return -1;
-  } finally {
-    if (timer) clearTimeout(timer);
-    if (signal) signal.removeEventListener('abort', onAbort);
-  }
-}
-
-export async function executeHook(
-  hooks: HooksConfig | undefined,
-  event: HookEvent,
-  context: unknown,
-  workDir?: string,
-  signal?: AbortSignal,
-): Promise<HookResult> {
-  if (!hooks) return { allowed: true, exitCode: 0 };
-
-  const commands = normalizeCommands(hooks[event]);
-  if (commands.length === 0) return { allowed: true, exitCode: 0 };
-
-  const isGate = GATE_HOOKS.has(event);
-
-  for (const cmd of commands) {
-    const exitCode = await runSingleHook(cmd, context, workDir, signal);
-
-    if (isGate && exitCode === 1) {
-      // Only exit code 1 has gate semantics (block execution)
-      return { allowed: false, exitCode };
-    }
-
-    if (exitCode !== 0) {
-      // Non-zero but not 1: hook itself had an error, log but don't block
-      console.warn(`[hook: ${event}] "${cmd}" exited with code ${exitCode}`);
-    }
-  }
-
-  return { allowed: true, exitCode: 0 };
-}
-
-// ═══ Context Builders ═══
-
-export interface PipelineInfo {
-  readonly name: string;
-  readonly run_id: string;
-  readonly started_at: string;
-  readonly finished_at?: string;
-  readonly duration_ms?: number;
-}
-
-export interface TrackInfo {
-  readonly id: string;
-  readonly name: string;
-}
-
-export interface TaskInfo {
-  readonly id: string;
-  readonly name: string;
-  readonly type: 'ai' | 'command';
-  readonly status: string;
-  readonly exit_code: number | null;
-  readonly duration_ms: number | null;
-  readonly stderr_path: string | null;
-  readonly session_id: string | null;
-  readonly started_at: string | null;
-  readonly finished_at: string | null;
-}
-
-export function buildPipelineStartContext(pipeline: PipelineInfo) {
-  return { event: 'pipeline_start', pipeline };
-}
-
-export function buildTaskContext(
-  event: 'task_start' | 'task_success' | 'task_failure',
-  pipeline: PipelineInfo,
-  track: TrackInfo,
-  task: TaskInfo,
-) {
-  return { event, pipeline, track, task };
-}
-
-export function buildPipelineCompleteContext(
-  pipeline: PipelineInfo & { finished_at: string; duration_ms: number },
-  summary: {
-    total: number;
-    success: number;
-    failed: number;
-    skipped: number;
-    timeout: number;
-    blocked: number;
-  },
-) {
-  return { event: 'pipeline_complete', pipeline, summary };
-}
-
-export function buildPipelineErrorContext(
-  pipeline: PipelineInfo,
-  error: string,
-  eventType?: string,
-  abortReason?: AbortReason,
-) {
-  return {
-    event: eventType ?? 'pipeline_error',
-    pipeline,
-    error,
-    ...(abortReason !== undefined ? { abort_reason: abortReason } : {}),
-  };
-}

package/src/index.ts

@@ -1,31 +0,0 @@
-export { createTagma } from './tagma';
-export type { CreateTagmaOptions, Tagma, TagmaRunOptions } from './tagma';
-export { bunRuntime } from '@tagma/runtime-bun';
-export type { TagmaRuntime, RunOptions as RuntimeRunOptions } from '@tagma/core';
-export { definePipeline, PluginRegistry, TriggerBlockedError, TriggerTimeoutError } from '@tagma/core';
-export type { EngineResult, RunEventPayload } from '@tagma/core';
-export { RUN_PROTOCOL_VERSION, TASK_LOG_CAP } from './types';
-export type {
-  PipelineConfig,
-  RawPipelineConfig,
-  RawTrackConfig,
-  RawTaskConfig,
-  TrackConfig,
-  TaskConfig,
-  RunSnapshotPayload,
-  WireRunEvent,
-  RunTaskState,
-  TaskLogLine,
-  ApprovalRequestInfo,
-  TaskStatus,
-  ApprovalRequest,
-  PluginCategory,
-  PluginCapabilities,
-  PluginSetupContext,
-  TagmaPlugin,
-  DriverPlugin,
-  TriggerPlugin,
-  CompletionPlugin,
-  MiddlewarePlugin,
-  RunEventPayload as PipelineRunEventPayload,
-} from '@tagma/types';

package/src/logger.ts

@@ -1,2 +0,0 @@
-export { clip, Logger, tailLines } from '@tagma/core';
-export type { LogLevel, LogListener, LogRecord } from '@tagma/core';

package/src/middlewares/static-context.ts

@@ -1,49 +0,0 @@
-import { basename } from 'path';
-import type { MiddlewarePlugin, MiddlewareContext, PromptDocument } from '../types';
-import { validatePath } from '../utils';
-import { appendContext } from '../prompt-doc';
-
-export const StaticContextMiddleware: MiddlewarePlugin = {
-  name: 'static_context',
-  schema: {
-    description: 'Prepend a reference file to the prompt as static context.',
-    fields: {
-      file: {
-        type: 'path',
-        required: true,
-        description: 'Path to the reference file (relative to workDir or absolute).',
-        placeholder: 'docs/spec.md',
-      },
-      label: {
-        type: 'string',
-        description: 'Header shown before the content. Defaults to "Reference: <basename>".',
-        placeholder: 'Reference: spec.md',
-      },
-    },
-  },
-
-  async enhanceDoc(
-    doc: PromptDocument,
-    config: Record<string, unknown>,
-    ctx: MiddlewareContext,
-  ): Promise<PromptDocument> {
-    const filePath = config.file as string;
-    if (!filePath) throw new Error('static_context middleware: "file" is required');
-
-    const safePath = validatePath(filePath, ctx.workDir);
-    const file = Bun.file(safePath);
-
-    if (!(await file.exists())) {
-      console.warn(`static_context: file ${filePath} not found, skipping`);
-      return doc;
-    }
-
-    const content = await file.text();
-    const label = (config.label as string) ?? `Reference: ${basename(filePath)}`;
-
-    // Append a labeled context block; the engine's serializer joins blocks
-    // with blank lines and places the task last. No [Task] header here —
-    // that framing is the driver's concern (e.g. opencode's agent_profile).
-    return appendContext(doc, { label, content });
-  },
-};

package/src/package-split.test.ts

@@ -1,15 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { PluginRegistry, InMemoryApprovalGateway } from '@tagma/core';
-import { bunRuntime } from '@tagma/runtime-bun';
-import { createTagma } from './index';
-
-describe('Phase 6 package split', () => {
-  test('sdk composes the core registry and bun runtime packages', () => {
-    const runtime = bunRuntime();
-    const tagma = createTagma({ runtime, builtins: false });
-
-    expect(tagma.registry).toBeInstanceOf(PluginRegistry);
-    expect(typeof runtime.runCommand).toBe('function');
-    expect(new InMemoryApprovalGateway().pending()).toEqual([]);
-  });
-});

package/src/pipeline-definition.ts

@@ -1,5 +0,0 @@
-import type { RawPipelineConfig } from './types';
-
-export function definePipeline<T extends RawPipelineConfig>(pipeline: T): T {
-  return pipeline;
-}