@tagma/sdk 0.7.4 → 0.7.6

package/src/yaml-compiler.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { compileYamlContent } from './yaml-compiler';
-
-describe('compileYamlContent', () => {
-  test('reports YAML syntax failures as parse errors', () => {
-    const result = compileYamlContent('pipeline:\n  name: [');
-
-    expect(result.parseOk).toBe(false);
-    expect(result.success).toBe(false);
-    expect(result.validation.errors).toEqual([]);
-    expect(result.summary).toMatch(/^YAML parse error:/);
-  });
-
-  test('reports missing top-level pipeline as a validation error', () => {
-    const result = compileYamlContent('name: Missing Pipeline\n');
-
-    expect(result.parseOk).toBe(true);
-    expect(result.success).toBe(false);
-    expect(result.validation.errors).toEqual([
-      { path: 'pipeline', message: 'Top-level "pipeline" key is required' },
-    ]);
-    expect(result.summary).toBe('Invalid: 1 error(s), 0 warning(s)');
-  });
-
-  test('reports non-array tracks as a validation error, not a parse failure', () => {
-    const result = compileYamlContent(`
-pipeline:
-  name: Bad
-  tracks:
-    id: not-an-array
-`);
-
-    expect(result.parseOk).toBe(true);
-    expect(result.success).toBe(false);
-    expect(result.validation.errors).toEqual([
-      { path: 'tracks', message: 'pipeline.tracks must be an array' },
-    ]);
-  });
-
-  test('reports non-array task lists as validation errors, not validation crashes', () => {
-    const result = compileYamlContent(`
-pipeline:
-  name: Bad Tasks
-  tracks:
-    - id: t
-      name: T
-      tasks:
-        id: not-an-array
-`);
-
-    expect(result.parseOk).toBe(true);
-    expect(result.success).toBe(false);
-    expect(result.validation.errors).toEqual([
-      { path: 'tracks[0].tasks', message: 'Track "t": tasks must be an array' },
-    ]);
-    expect(result.summary).not.toMatch(/Validation crashed/);
-  });
-
-  test('routes schema errors through validation when YAML syntax is valid', () => {
-    const result = compileYamlContent(`
-pipeline:
-  name: Missing Track Name
-  tracks:
-    - id: main
-      tasks:
-        - id: task
-          prompt: hello
-`);
-
-    expect(result.parseOk).toBe(true);
-    expect(result.success).toBe(false);
-    expect(result.validation.errors).toContainEqual({
-      path: 'tracks[0].name',
-      message: 'Track name is required',
-    });
-  });
-
-  test('validates pipeline, track, and task permissions shape', () => {
-    const result = compileYamlContent(`
-pipeline:
-  name: Bad Permissions
-  permissions: { read: true, write: "yes", execute: false }
-  tracks:
-    - id: main
-      name: Main
-      permissions: { read: true, execute: false }
-      tasks:
-        - id: task
-          prompt: hello
-          permissions: nope
-`);
-
-    expect(result.parseOk).toBe(true);
-    expect(result.success).toBe(false);
-    expect(result.validation.errors).toContainEqual({
-      path: 'permissions.write',
-      message: 'permissions.write must be a boolean',
-    });
-    expect(result.validation.errors).toContainEqual({
-      path: 'tracks[0].permissions.write',
-      message: 'permissions.write is required',
-    });
-    expect(result.validation.errors).toContainEqual({
-      path: 'tracks[0].tasks[0].permissions',
-      message: 'permissions must be an object with read/write/execute booleans',
-    });
-  });
-});

package/src/yaml-compiler.ts

@@ -1,110 +0,0 @@
-import yaml from 'js-yaml';
-import { validateRaw } from './validate-raw';
-import type { ValidationError, KnownPluginTypes } from './validate-raw';
-import type { RawPipelineConfig } from './types';
-
-export interface YamlCompileResult {
-  readonly timestamp: string;
-  readonly sourceName: string;
-  readonly success: boolean;
-  readonly parseOk: boolean;
-  readonly validation: {
-    readonly errors: ReadonlyArray<Pick<ValidationError, 'path' | 'message'>>;
-    readonly warnings: ReadonlyArray<Pick<ValidationError, 'path' | 'message'>>;
-  };
-  readonly summary: string;
-}
-
-export interface CompileYamlOptions {
-  readonly sourceName?: string;
-  readonly knownTypes?: KnownPluginTypes;
-}
-
-export function compileYamlContent(
-  content: string,
-  opts: CompileYamlOptions = {},
-): YamlCompileResult {
-  const timestamp = new Date().toISOString();
-  const sourceName = opts.sourceName ?? 'untitled';
-
-  let doc: unknown;
-  try {
-    doc = yaml.load(content);
-  } catch (err) {
-    return {
-      timestamp,
-      sourceName,
-      success: false,
-      parseOk: false,
-      validation: { errors: [], warnings: [] },
-      summary: `YAML parse error: ${errorMessage(err)}`,
-    };
-  }
-
-  const envelopeErrors = validateEnvelope(doc);
-  if (envelopeErrors.length > 0) {
-    return buildValidationResult(timestamp, sourceName, envelopeErrors);
-  }
-  const config = (doc as { pipeline: RawPipelineConfig }).pipeline;
-
-  let errors: ValidationError[];
-  try {
-    errors = validateRaw(config, opts.knownTypes);
-  } catch (err) {
-    return {
-      timestamp,
-      sourceName,
-      success: false,
-      parseOk: true,
-      validation: { errors: [], warnings: [] },
-      summary: `Validation crashed: ${errorMessage(err)}`,
-    };
-  }
-
-  return buildValidationResult(timestamp, sourceName, errors);
-}
-
-function validateEnvelope(doc: unknown): ValidationError[] {
-  if (!doc || typeof doc !== 'object' || Array.isArray(doc) || !('pipeline' in doc)) {
-    return [{ path: 'pipeline', message: 'Top-level "pipeline" key is required' }];
-  }
-  const pipeline = (doc as Record<string, unknown>).pipeline;
-  if (!pipeline || typeof pipeline !== 'object' || Array.isArray(pipeline)) {
-    return [{ path: 'pipeline', message: 'pipeline must be an object' }];
-  }
-  return [];
-}
-
-function buildValidationResult(
-  timestamp: string,
-  sourceName: string,
-  diagnostics: readonly ValidationError[],
-): YamlCompileResult {
-  const validationErrors = diagnostics.filter(
-    (e) => e.severity === 'error' || e.severity == null,
-  );
-  const validationWarnings = diagnostics.filter((e) => e.severity === 'warning');
-
-  return {
-    timestamp,
-    sourceName,
-    success: validationErrors.length === 0,
-    parseOk: true,
-    validation: {
-      errors: validationErrors.map((e) => ({ path: e.path, message: e.message })),
-      warnings: validationWarnings.map((e) => ({ path: e.path, message: e.message })),
-    },
-    summary:
-      validationErrors.length === 0
-        ? validationWarnings.length === 0
-          ? 'Valid pipeline configuration'
-          : `Valid with ${validationWarnings.length} warning(s)`
-        : `Invalid: ${validationErrors.length} error(s), ${validationWarnings.length} warning(s)`,
-  };
-}
-
-function errorMessage(err: unknown): string {
-  if (err instanceof Error && err.message) return err.message;
-  if (typeof err === 'string') return err;
-  return 'Unknown error';
-}

package/src/yaml.ts

@@ -1,11 +0,0 @@
-export {
-  parseYaml,
-  resolveConfig,
-  loadPipeline,
-  serializePipeline,
-  deresolvePipeline,
-  validateConfig,
-} from './schema';
-export { compileYamlContent } from './yaml-compiler';
-export type { YamlCompileResult, CompileYamlOptions } from './yaml-compiler';
-