@tagma/sdk 0.4.7 → 0.4.9

package/src/schema.test.ts

@@ -1,97 +1,97 @@
-import { describe, expect, test } from 'bun:test';
-import yaml from 'js-yaml';
-import type { PipelineConfig, RawPipelineConfig } from './types';
-import { deresolvePipeline, 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('deresolvePipeline also omits the default exit_code completion', () => {
-    const resolved: PipelineConfig = {
-      name: 'Deresolve Defaults',
-      tracks: [
-        {
-          id: 'track_a',
-          name: 'Track A',
-          driver: 'claude-code',
-          permissions: { read: true, write: false, execute: false },
-          on_failure: 'skip_downstream',
-          cwd: 'D:/workspace',
-          tasks: [
-            {
-              id: 'task_1',
-              name: 'Task 1',
-              prompt: 'hello',
-              driver: 'claude-code',
-              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: 'claude-code',
-              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',
-    });
-  });
-});
+import { describe, expect, test } from 'bun:test';
+import yaml from 'js-yaml';
+import type { PipelineConfig, RawPipelineConfig } from './types';
+import { parseYaml, deresolvePipeline, 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('deresolvePipeline also omits the default exit_code completion', () => {
+    const resolved: PipelineConfig = {
+      name: 'Deresolve Defaults',
+      tracks: [
+        {
+          id: 'track_a',
+          name: 'Track A',
+          driver: 'claude-code',
+          permissions: { read: true, write: false, execute: false },
+          on_failure: 'skip_downstream',
+          cwd: 'D:/workspace',
+          tasks: [
+            {
+              id: 'task_1',
+              name: 'Task 1',
+              prompt: 'hello',
+              driver: 'claude-code',
+              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: 'claude-code',
+              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',
+    });
+  });
+});

package/src/schema.ts

@@ -1,11 +1,10 @@
-import yaml from 'js-yaml';
-import { resolve, relative } from 'path';
-import type {
-  PipelineConfig, RawPipelineConfig, RawTrackConfig, RawTaskConfig,
-  TrackConfig, TaskConfig, Permissions, MiddlewareConfig, CompletionConfig,
-  TemplateConfig, TemplateParamDef,
-} from './types';
-import { truncateForName, validatePathParam, validatePath } from './utils';
+import yaml from 'js-yaml';
+import { resolve, relative } from 'path';
+import type {
+  PipelineConfig, RawPipelineConfig, RawTrackConfig, RawTaskConfig,
+  TrackConfig, TaskConfig, Permissions, MiddlewareConfig, CompletionConfig,
+} from './types';
+import { truncateForName, validatePath } from './utils';
 import { DEFAULT_PERMISSIONS } from './types';
 import { buildDag } from './dag';
 
@@ -39,7 +38,6 @@ function validateRawTrack(track: RawTrackConfig): void {
 
 function validateRawTask(task: RawTaskConfig, trackId: string): void {
   if (!task.id) throw new Error(`track "${trackId}": task.id is required`);
-  if (task.use) return; // template usage, validated later
 
   const hasPromptKey = typeof task.prompt === 'string';
   const hasCommandKey = typeof task.command === 'string';
@@ -53,168 +51,6 @@ function validateRawTask(task: RawTaskConfig, trackId: string): void {
   // flagged as non-fatal validation errors by validate-raw.ts.
 }
 
-// ═══ Template Expansion ═══
-
-export async function expandTemplates(
-  tasks: readonly RawTaskConfig[],
-  instancePrefix: string,
-): Promise<RawTaskConfig[]> {
-  const result: RawTaskConfig[] = [];
-
-  for (const task of tasks) {
-    if (!task.use) {
-      result.push(task);
-      continue;
-    }
-
-    const template = await loadTemplate(task.use);
-    const params = resolveTemplateParams(template, task.with ?? {}, task.id);
-    const expanded = expandTemplateTask(template, params, task.id, instancePrefix);
-    result.push(...expanded);
-  }
-
-  return result;
-}
-
-function validateTemplateRef(ref: string): void {
-  const stripped = ref.replace(/@v\d+$/, '');
-  // Reject path traversal and absolute paths before they reach import().
-  if (stripped.includes('..') || stripped.startsWith('/') || /^[a-zA-Z]:/.test(stripped)) {
-    throw new Error(
-      `Invalid template ref "${ref}": path traversal and absolute paths are not allowed. ` +
-      `Use a scoped package name, e.g. "@tagma/template-review".`
-    );
-  }
-  // Whitelist: only @tagma/template-* packages are allowed.
-  if (!stripped.startsWith('@tagma/template-')) {
-    throw new Error(
-      `Invalid template ref "${ref}": only "@tagma/template-*" packages are allowed as templates. ` +
-      `Example: "@tagma/template-review".`
-    );
-  }
-}
-
-async function loadTemplate(ref: string): Promise<TemplateConfig> {
-  validateTemplateRef(ref);
-  // Strip version suffix for import
-  const moduleName = ref.replace(/@v\d+$/, '');
-  try {
-    const mod = await import(moduleName);
-    // Expect the module to export a template.yaml content or parsed object
-    if (mod.template) return mod.template as TemplateConfig;
-
-    // Try loading template.yaml from the package.
-    // NOTE: require.resolve is a CommonJS API. Bun supports it natively, but
-    // this would need import.meta.resolve() for pure ESM runtimes (e.g. Deno).
-    const pkgPath = require.resolve(`${moduleName}/template.yaml`);
-    const content = await Bun.file(pkgPath).text();
-    const doc = yaml.load(content) as { template: TemplateConfig };
-    return doc.template;
-  } catch (err) {
-    if (err instanceof Error && err.message.startsWith('Invalid template ref')) throw err;
-    throw new Error(`Failed to load template: "${ref}". Is the package installed?`);
-  }
-}
-
-function resolveTemplateParams(
-  template: TemplateConfig,
-  provided: Record<string, unknown>,
-  instanceId: string,
-): Record<string, unknown> {
-  const params: Record<string, unknown> = {};
-  const defs = template.params ?? {};
-
-  for (const [key, def] of Object.entries(defs)) {
-    const value = provided[key] ?? def.default;
-    if (value === undefined) {
-      throw new Error(`Template "${template.name}" instance "${instanceId}": missing required param "${key}"`);
-    }
-    validateParamType(key, value, def, template.name, instanceId);
-    params[key] = value;
-  }
-
-  // Warn about unknown params
-  for (const key of Object.keys(provided)) {
-    if (!(key in defs)) {
-      console.warn(`Template "${template.name}" instance "${instanceId}": unknown param "${key}"`);
-    }
-  }
-
-  return params;
-}
-
-function validateParamType(
-  key: string, value: unknown, def: TemplateParamDef,
-  templateName: string, instanceId: string,
-): void {
-  const ctx = `Template "${templateName}" instance "${instanceId}" param "${key}"`;
-  const ptype = def.type ?? 'string';
-
-  switch (ptype) {
-    case 'string':
-      if (typeof value !== 'string') throw new Error(`${ctx}: expected string, got ${typeof value}`);
-      break;
-    case 'path':
-      if (typeof value !== 'string') throw new Error(`${ctx}: expected path string, got ${typeof value}`);
-      validatePathParam(value);
-      break;
-    case 'enum':
-      if (!def.enum?.includes(value as string)) {
-        throw new Error(`${ctx}: value "${value}" not in allowed values [${def.enum?.join(', ')}]`);
-      }
-      break;
-    case 'number':
-      if (typeof value !== 'number') throw new Error(`${ctx}: expected number, got ${typeof value}`);
-      if (def.min !== undefined && value < def.min) throw new Error(`${ctx}: ${value} < min ${def.min}`);
-      if (def.max !== undefined && value > def.max) throw new Error(`${ctx}: ${value} > max ${def.max}`);
-      break;
-  }
-}
-
-function expandTemplateTask(
-  template: TemplateConfig,
-  params: Record<string, unknown>,
-  instanceId: string,
-  instancePrefix: string,
-): RawTaskConfig[] {
-  return template.tasks.map(task => {
-    const prefixedId = `${instanceId}.${task.id}`;
-
-    // Replace ${{ params.xxx }} in string fields
-    const interpolate = (s: string): string =>
-      s.replace(/\$\{\{\s*params\.(\w+)\s*\}\}/g, (_, key) => String(params[key] ?? ''));
-
-    const newTask: Record<string, unknown> = { ...task, id: prefixedId };
-
-    // Interpolate string fields
-    if (task.prompt) newTask.prompt = interpolate(task.prompt);
-    if (task.command) newTask.command = interpolate(task.command);
-
-    // Namespace depends_on
-    if (task.depends_on) {
-      newTask.depends_on = task.depends_on.map(dep => `${instanceId}.${dep}`);
-    }
-
-    // Namespace continue_from
-    if (task.continue_from) {
-      newTask.continue_from = `${instanceId}.${task.continue_from}`;
-    }
-
-    // Rewrite output path to instance namespace so parallel template
-    // instances don't collide on the same file. Handles any relative path
-    // (e.g. ./tmp/foo, ./output/bar, ./build/result.json) by injecting
-    // the instanceId as the first directory component after `./`.
-    if (task.output) {
-      const original = interpolate(task.output);
-      newTask.output = original.startsWith('./')
-        ? `./${instanceId}/${original.slice(2)}`
-        : `${instanceId}/${original}`;
-    }
-
-    return newTask as unknown as RawTaskConfig;
-  });
-}
-
 // ═══ Config Inheritance Resolution ═══
 
 export function resolveConfig(raw: RawPipelineConfig, workDir: string): PipelineConfig {
@@ -263,7 +99,6 @@ export function resolveConfig(raw: RawPipelineConfig, workDir: string): Pipeline
         continue_from: rawTask.continue_from
           ? qualifyContinueFrom(rawTask.continue_from, rawTrack.id)
           : undefined,
-        output: rawTask.output,
         // Inheritance: Task > Track > Pipeline
         model: rawTask.model ?? rawTrack.model ?? raw.model,
         reasoning_effort: rawTask.reasoning_effort ?? rawTrack.reasoning_effort ?? raw.reasoning_effort,
@@ -307,42 +142,42 @@ export function resolveConfig(raw: RawPipelineConfig, workDir: string): Pipeline
 }
 
 // Field-by-field permissions comparison — avoids relying on JSON.stringify key order.
-function permissionsEqual(a: Permissions | undefined, b: Permissions | undefined): boolean {
-  if (a === b) return true;
-  if (!a || !b) return false;
-  return a.read === b.read && a.write === b.write && a.execute === b.execute;
-}
-
-function isDefaultExitCodeCompletion(
-  completion: CompletionConfig | undefined,
-): boolean {
-  if (!completion || completion.type !== 'exit_code') return false;
-  const { type: _type, expect, ...rest } = completion as CompletionConfig & {
-    expect?: unknown;
-  };
-  if (Object.keys(rest).length > 0) return false;
-  return expect === undefined || expect === 0;
-}
-
-function stripDefaultTaskCompletion<T extends { completion?: CompletionConfig }>(
-  task: T,
-): T {
-  if (!isDefaultExitCodeCompletion(task.completion)) return task;
-  const { completion: _completion, ...rest } = task;
-  return rest as T;
-}
-
-function stripDefaultCompletionsForSerialization<
-  T extends PipelineConfig | RawPipelineConfig,
->(config: T): T {
-  return {
-    ...config,
-    tracks: config.tracks.map((track) => ({
-      ...track,
-      tasks: track.tasks.map((task) => stripDefaultTaskCompletion(task)),
-    })),
-  } as T;
-}
+function permissionsEqual(a: Permissions | undefined, b: Permissions | undefined): boolean {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.read === b.read && a.write === b.write && a.execute === b.execute;
+}
+
+function isDefaultExitCodeCompletion(
+  completion: CompletionConfig | undefined,
+): boolean {
+  if (!completion || completion.type !== 'exit_code') return false;
+  const { type: _type, expect, ...rest } = completion as CompletionConfig & {
+    expect?: unknown;
+  };
+  if (Object.keys(rest).length > 0) return false;
+  return expect === undefined || expect === 0;
+}
+
+function stripDefaultTaskCompletion<T extends { completion?: CompletionConfig }>(
+  task: T,
+): T {
+  if (!isDefaultExitCodeCompletion(task.completion)) return task;
+  const { completion: _completion, ...rest } = task;
+  return rest as T;
+}
+
+function stripDefaultCompletionsForSerialization<
+  T extends PipelineConfig | RawPipelineConfig,
+>(config: T): T {
+  return {
+    ...config,
+    tracks: config.tracks.map((track) => ({
+      ...track,
+      tasks: track.tasks.map((task) => stripDefaultTaskCompletion(task)),
+    })),
+  } as T;
+}
 
 // ═══ YAML Serialization ═══
 
@@ -350,12 +185,12 @@ function stripDefaultCompletionsForSerialization<
  * Serialize a pipeline config back to YAML string.
  * Wraps the config under the top-level `pipeline` key as expected by parseYaml.
  */
-export function serializePipeline(config: PipelineConfig | RawPipelineConfig): string {
-  return yaml.dump(
-    { pipeline: stripDefaultCompletionsForSerialization(config) },
-    { lineWidth: 120, indent: 2 },
-  );
-}
+export function serializePipeline(config: PipelineConfig | RawPipelineConfig): string {
+  return yaml.dump(
+    { pipeline: stripDefaultCompletionsForSerialization(config) },
+    { lineWidth: 120, indent: 2 },
+  );
+}
 
 /**
  * Convert a resolved PipelineConfig back to a RawPipelineConfig for serialization.
@@ -388,7 +223,6 @@ export function deresolvePipeline(config: PipelineConfig, workDir: string): RawP
         ...(task.depends_on?.length ? { depends_on: task.depends_on } : {}),
         ...(task.trigger ? { trigger: task.trigger } : {}),
         ...(task.continue_from ? { continue_from: task.continue_from } : {}),
-        ...(task.output ? { output: task.output } : {}),
         ...(taskCwdRel ? { cwd: taskCwdRel } : {}),
         ...(task.model && task.model !== effectiveTrackModel ? { model: task.model } : {}),
         ...(task.reasoning_effort && task.reasoning_effort !== effectiveTrackReasoning
@@ -397,9 +231,9 @@ export function deresolvePipeline(config: PipelineConfig, workDir: string): RawP
         ...(task.driver && task.driver !== effectiveTrackDriver ? { driver: task.driver } : {}),
         ...(task.timeout ? { timeout: task.timeout } : {}),
         ...(task.middlewares !== undefined ? { middlewares: task.middlewares } : {}),
-        ...(task.completion && !isDefaultExitCodeCompletion(task.completion)
-          ? { completion: task.completion }
-          : {}),
+        ...(task.completion && !isDefaultExitCodeCompletion(task.completion)
+          ? { completion: task.completion }
+          : {}),
         ...(task.agent_profile ? { agent_profile: task.agent_profile } : {}),
         ...(task.permissions && !permissionsEqual(task.permissions, track.permissions)
           ? { permissions: task.permissions }
@@ -460,14 +294,5 @@ export function validateConfig(config: PipelineConfig): string[] {
 
 export async function loadPipeline(yamlContent: string, workDir: string): Promise<PipelineConfig> {
   const raw = parseYaml(yamlContent);
-
-  // Expand templates in each track
-  const expandedTracks: RawTrackConfig[] = [];
-  for (const track of raw.tracks) {
-    const expandedTasks = await expandTemplates(track.tasks, track.id);
-    expandedTracks.push({ ...track, tasks: expandedTasks });
-  }
-
-  const expandedRaw: RawPipelineConfig = { ...raw, tracks: expandedTracks };
-  return resolveConfig(expandedRaw, workDir);
+  return resolveConfig(raw, workDir);
 }

package/src/sdk.ts

@@ -30,11 +30,7 @@ export { validateRaw } from './validate-raw';
 export type { ValidationError } from './validate-raw';
 
 // ── Schema: parse / resolve / load / serialize / validate ──
-export { parseYaml, resolveConfig, expandTemplates, loadPipeline, serializePipeline, deresolvePipeline, validateConfig } from './schema';
-
-// ── Templates: discovery + manifest loading (F1) ──
-export { discoverTemplates, loadTemplateManifest } from './templates';
-export type { TemplateManifest } from './templates';
+export { parseYaml, resolveConfig, loadPipeline, serializePipeline, deresolvePipeline, validateConfig } from './schema';
 
 // ── DAG ──
 export { buildDag, buildRawDag } from './dag';

package/src/utils.ts

@@ -33,20 +33,6 @@ export function validatePath(filePath: string, projectRoot: string): string {
   return resolved;
 }
 
-const SHELL_META_CHARS = /[;&|$`\\!><()\[\]{}*?#~]/;
-
-export function validatePathParam(filePath: string): void {
-  if (filePath.includes('..')) {
-    throw new Error(`Template param type=path: ".." traversal not allowed in "${filePath}"`);
-  }
-  if (resolve(filePath) === filePath) {
-    throw new Error(`Template param type=path: absolute path not allowed: "${filePath}"`);
-  }
-  if (SHELL_META_CHARS.test(filePath)) {
-    throw new Error(`Template param type=path: shell metacharacters not allowed in "${filePath}"`);
-  }
-}
-
 let runCounter = 0;
 
 export function generateRunId(): string {

package/src/validate-raw.ts

@@ -180,9 +180,6 @@ export function validateRaw(
       }
       seenTaskIds.add(task.id);
 
-      // Template-based tasks: skip prompt/command checks (params validated at runtime)
-      if (task.use) continue;
-
       const hasPromptKey = typeof task.prompt === 'string';
       const hasCommandKey = typeof task.command === 'string';
       const promptEmpty = hasPromptKey && task.prompt!.trim().length === 0;
@@ -333,7 +330,7 @@ function detectCycles(
   for (const track of config.tracks) {
     if (!track.id) continue;
     for (const task of track.tasks ?? []) {
-      if (!task.id || task.use) continue;
+      if (!task.id) continue;
       const qid = `${track.id}.${task.id}`;
       const deps: string[] = [];
       for (const dep of task.depends_on ?? []) {