@tagma/sdk 0.7.4 → 0.7.6

package/src/schema-ports.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import yaml from 'js-yaml';
-import type { PipelineConfig, RawPipelineConfig } from './types';
-import { deresolvePipeline, parseYaml, resolveConfig, serializePipeline } from './schema';
-
-const WORK_DIR = process.platform === 'win32' ? 'D:\\fake-work' : '/fake-work';
-
-describe('schema — unified bindings passthrough', () => {
-  test('typed inputs and outputs survive onto the resolved task', () => {
-    const raw: RawPipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          tasks: [
-            {
-              id: 'a',
-              command: 'echo "{{inputs.city}}"',
-              inputs: { city: { from: 't.plan.outputs.city', type: 'string', required: true } },
-              outputs: { report: { from: 'json.reportPath', type: 'string' } },
-            },
-          ],
-        },
-      ],
-    };
-    const task = resolveConfig(raw, WORK_DIR).tracks[0]!.tasks[0]!;
-    expect(task.inputs).toEqual(raw.tracks[0]!.tasks[0]!.inputs!);
-    expect(task.outputs).toEqual(raw.tracks[0]!.tasks[0]!.outputs!);
-  });
-
-  test('typed inputs and outputs round-trip through deresolve', () => {
-    const raw: RawPipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          tasks: [
-            {
-              id: 'a',
-              command: 'echo "{{inputs.city}}"',
-              inputs: {
-                city: {
-                  from: 't.plan.outputs.city',
-                  type: 'enum',
-                  enum: ['Shanghai', 'Paris'],
-                  required: true,
-                },
-              },
-              outputs: { raw: { from: 'stdout' } },
-            },
-          ],
-        },
-      ],
-    };
-    const back = deresolvePipeline(resolveConfig(raw, WORK_DIR), WORK_DIR);
-    expect(back.tracks[0]!.tasks[0]!.inputs).toEqual(raw.tracks[0]!.tasks[0]!.inputs!);
-    expect(back.tracks[0]!.tasks[0]!.outputs).toEqual(raw.tracks[0]!.tasks[0]!.outputs!);
-  });
-
-  test('empty binding maps are dropped on deresolve', () => {
-    const resolved: PipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          tasks: [
-            {
-              id: 'a',
-              name: 'a',
-              prompt: 'hi',
-              inputs: {},
-              outputs: {},
-            },
-          ],
-        },
-      ],
-    };
-    const back = deresolvePipeline(resolved, WORK_DIR);
-    expect(back.tracks[0]!.tasks[0]!.inputs).toBeUndefined();
-    expect(back.tracks[0]!.tasks[0]!.outputs).toBeUndefined();
-  });
-
-  test('legacy ports are not carried through resolve or deresolve', () => {
-    const raw: RawPipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          tasks: [
-            {
-              id: 'a',
-              command: 'echo ok',
-              ports: { outputs: [{ name: 'old', type: 'string' }] },
-            },
-          ],
-        },
-      ],
-    };
-    const resolved = resolveConfig(raw, WORK_DIR);
-    expect(resolved.tracks[0]!.tasks[0]!.ports).toBeUndefined();
-    const back = deresolvePipeline(resolved, WORK_DIR);
-    expect(back.tracks[0]!.tasks[0]!.ports).toBeUndefined();
-  });
-
-  test('YAML round-trip preserves typed unified binding shape', () => {
-    const raw: RawPipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          tasks: [
-            {
-              id: 'classify',
-              prompt: 'pick a bucket',
-              inputs: { doc: { type: 'string', required: true, description: 'Full text' } },
-              outputs: {
-                bucket: {
-                  type: 'enum',
-                  enum: ['spam', 'ham'],
-                  description: 'Classification',
-                },
-              },
-            },
-          ],
-        },
-      ],
-    };
-    const yamlText = serializePipeline(raw);
-    const parsed = (yaml.load(yamlText) as { pipeline: RawPipelineConfig }).pipeline;
-    expect(parsed.tracks[0]!.tasks[0]!.inputs).toEqual(raw.tracks[0]!.tasks[0]!.inputs!);
-    expect(parsed.tracks[0]!.tasks[0]!.outputs).toEqual(raw.tracks[0]!.tasks[0]!.outputs!);
-  });
-
-  test('real-world YAML with typed bindings parses cleanly', () => {
-    const text = `pipeline:
-  name: demo
-  tracks:
-    - id: t
-      name: Main
-      tasks:
-        - id: build
-          command: bun run build
-          outputs:
-            bundlePath:
-              from: json.bundlePath
-              type: string
-        - id: test
-          depends_on: [build]
-          command: 'bun test "{{inputs.bundlePath}}"'
-          inputs:
-            bundlePath:
-              from: t.build.outputs.bundlePath
-              type: string
-              required: true
-`;
-    const config = parseYaml(text);
-    expect(config.tracks[0]!.tasks[0]!.outputs!.bundlePath).toEqual({
-      from: 'json.bundlePath',
-      type: 'string',
-    });
-    expect(config.tracks[0]!.tasks[1]!.inputs!.bundlePath).toEqual({
-      from: 't.build.outputs.bundlePath',
-      type: 'string',
-      required: true,
-    });
-  });
-});

package/src/schema.test.ts

@@ -1,213 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import yaml from 'js-yaml';
-import type { PipelineConfig, RawPipelineConfig } from './types';
-import { deresolvePipeline, parseYaml, resolveConfig, serializePipeline } from './schema';
-
-function parsePipelineYaml(content: string): RawPipelineConfig {
-  const doc = yaml.load(content) as { pipeline: RawPipelineConfig };
-  return doc.pipeline;
-}
-
-describe('completion default serialization', () => {
-  test('serializePipeline omits default exit_code completions from raw configs', () => {
-    const raw: RawPipelineConfig = {
-      name: 'Serialize Defaults',
-      tracks: [
-        {
-          id: 'track_a',
-          name: 'Track A',
-          tasks: [
-            { id: 'task_1', prompt: 'hello', completion: { type: 'exit_code' } },
-            { id: 'task_2', prompt: 'world', completion: { type: 'exit_code', expect: 0 } },
-            { id: 'task_3', prompt: 'keep me', completion: { type: 'exit_code', expect: 2 } },
-          ],
-        },
-      ],
-    };
-
-    const parsed = parsePipelineYaml(serializePipeline(raw));
-    expect(parsed.tracks[0].tasks[0].completion).toBeUndefined();
-    expect(parsed.tracks[0].tasks[1].completion).toBeUndefined();
-    expect(parsed.tracks[0].tasks[2].completion).toEqual({ type: 'exit_code', expect: 2 });
-  });
-
-  test('serializePipeline preserves non-default completion plugins', () => {
-    const raw: RawPipelineConfig = {
-      name: 'Serialize Explicit',
-      tracks: [
-        {
-          id: 'track_a',
-          name: 'Track A',
-          tasks: [
-            {
-              id: 'task_1',
-              prompt: 'check file',
-              completion: { type: 'file_exists', path: './out.txt' },
-            },
-          ],
-        },
-      ],
-    };
-
-    const parsed = parsePipelineYaml(serializePipeline(raw));
-    expect(parsed.tracks[0].tasks[0].completion).toEqual({
-      type: 'file_exists',
-      path: './out.txt',
-    });
-  });
-
-  test('serializePipeline drops continue_from from command tasks (prompt-only field)', () => {
-    const raw: RawPipelineConfig = {
-      name: 'Strip Continue From',
-      tracks: [
-        {
-          id: 'track_a',
-          name: 'Track A',
-          tasks: [
-            { id: 'upstream', prompt: 'generate something' },
-            // Simulates a task the user authored as `prompt` with a
-            // continue_from, then toggled to `command` in the editor panel.
-            // The field should not survive serialization.
-            {
-              id: 'downstream',
-              command: 'bun run build',
-              continue_from: 'upstream',
-              depends_on: ['upstream'],
-            },
-            // A prompt task keeps its continue_from as-is.
-            { id: 'threaded', prompt: 'refine', continue_from: 'upstream' },
-          ],
-        },
-      ],
-    };
-
-    const parsed = parsePipelineYaml(serializePipeline(raw));
-    expect(parsed.tracks[0].tasks[1].continue_from).toBeUndefined();
-    expect(parsed.tracks[0].tasks[1].depends_on).toEqual(['upstream']);
-    expect(parsed.tracks[0].tasks[2].continue_from).toBe('upstream');
-  });
-
-  test('deresolvePipeline also omits the default exit_code completion', () => {
-    const resolved: PipelineConfig = {
-      name: 'Deresolve Defaults',
-      tracks: [
-        {
-          id: 'track_a',
-          name: 'Track A',
-          driver: 'opencode',
-          permissions: { read: true, write: false, execute: false },
-          on_failure: 'skip_downstream',
-          cwd: 'D:/workspace',
-          tasks: [
-            {
-              id: 'task_1',
-              name: 'Task 1',
-              prompt: 'hello',
-              driver: 'opencode',
-              permissions: { read: true, write: false, execute: false },
-              cwd: 'D:/workspace',
-              completion: { type: 'exit_code', expect: 0 },
-            },
-            {
-              id: 'task_2',
-              name: 'Task 2',
-              prompt: 'custom',
-              driver: 'opencode',
-              permissions: { read: true, write: false, execute: false },
-              cwd: 'D:/workspace',
-              completion: { type: 'output_check', check: 'test -f ./done.txt' },
-            },
-          ],
-        },
-      ],
-    };
-
-    const raw = deresolvePipeline(resolved, 'D:/workspace');
-    expect(raw.tracks[0].tasks[0].completion).toBeUndefined();
-    expect(raw.tracks[0].tasks[1].completion).toEqual({
-      type: 'output_check',
-      check: 'test -f ./done.txt',
-    });
-  });
-});
-
-describe('parseYaml structural validation', () => {
-  test('rejects non-array pipeline.tracks with a clear error', () => {
-    expect(() =>
-      parseYaml(`
-pipeline:
-  name: Bad
-  tracks:
-    id: not-an-array
-`),
-    ).toThrow(/pipeline\.tracks must be an array/);
-  });
-
-  test('rejects non-array track.tasks with a clear error', () => {
-    expect(() =>
-      parseYaml(`
-pipeline:
-  name: Bad
-  tracks:
-    - id: t
-      name: T
-      tasks:
-        id: not-an-array
-`),
-    ).toThrow(/track "t": tasks must be an array/);
-  });
-});
-
-describe('permissions inheritance', () => {
-  test('resolveConfig applies pipeline-level permissions to tracks and tasks', () => {
-    const raw: RawPipelineConfig = {
-      name: 'Pipeline Permissions',
-      permissions: { read: true, write: true, execute: false },
-      tracks: [
-        {
-          id: 'track_a',
-          name: 'Track A',
-          tasks: [{ id: 'task_1', prompt: 'hello' }],
-        },
-      ],
-    };
-
-    const resolved = resolveConfig(raw, 'D:/workspace');
-    expect(resolved.tracks[0].permissions).toEqual({ read: true, write: true, execute: false });
-    expect(resolved.tracks[0].tasks[0].permissions).toEqual({
-      read: true,
-      write: true,
-      execute: false,
-    });
-  });
-
-  test('deresolvePipeline preserves pipeline-level permissions without repeating inherited values', () => {
-    const resolved: PipelineConfig = {
-      name: 'Deresolve Permissions',
-      permissions: { read: true, write: true, execute: false },
-      tracks: [
-        {
-          id: 'track_a',
-          name: 'Track A',
-          permissions: { read: true, write: true, execute: false },
-          cwd: 'D:/workspace',
-          tasks: [
-            {
-              id: 'task_1',
-              name: 'Task 1',
-              prompt: 'hello',
-              permissions: { read: true, write: true, execute: false },
-              cwd: 'D:/workspace',
-            },
-          ],
-        },
-      ],
-    };
-
-    const raw = deresolvePipeline(resolved, 'D:/workspace');
-
-    expect(raw.permissions).toEqual({ read: true, write: true, execute: false });
-    expect(raw.tracks[0].permissions).toBeUndefined();
-    expect(raw.tracks[0].tasks[0].permissions).toBeUndefined();
-  });
-});