@studio-foundation/engine 0.3.0-beta.1 → 0.3.0-beta.5

package/src/pipeline/context-propagation.test.ts

@@ -1,237 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  createInitialContext,
-  getContextForStage,
-  addStageOutput,
-  buildContextKeys,
-  buildContextContent,
-} from './context-propagation.js';
-import type { StageDefinition, ToolCall } from '@studio-foundation/contracts';
-import type { AgentContext } from '@studio-foundation/runner';
-
-const makeStage = (include: string[]): StageDefinition => ({
-  name: 'test-stage',
-  kind: 'analysis',
-  agent: 'analyst',
-  context: { include },
-});
-
-describe('getContextForStage — pipeline_start_context', () => {
-  it('injects startup_context when stage includes pipeline_start_context', () => {
-    const ctx = createInitialContext('my input');
-    ctx.startupContext = { git_status: 'M src/foo.ts', recent_commits: 'abc123 feat: stuff' };
-
-    const agentCtx = getContextForStage(ctx, makeStage(['pipeline_start_context']));
-    expect(agentCtx.startup_context).toEqual({
-      git_status: 'M src/foo.ts',
-      recent_commits: 'abc123 feat: stuff',
-    });
-  });
-
-  it('does not inject startup_context when not in include list', () => {
-    const ctx = createInitialContext('my input');
-    ctx.startupContext = { git_status: 'M src/foo.ts' };
-
-    const agentCtx = getContextForStage(ctx, makeStage(['input']));
-    expect(agentCtx.startup_context).toBeUndefined();
-  });
-
-  it('does not inject startup_context when startupContext is empty', () => {
-    const ctx = createInitialContext('my input');
-    ctx.startupContext = {};
-
-    const agentCtx = getContextForStage(ctx, makeStage(['pipeline_start_context']));
-    expect(agentCtx.startup_context).toBeUndefined();
-  });
-});
-
-describe('addStageOutput — size tracking', () => {
-  it('tracks serialized size when output is added', () => {
-    const ctx = createInitialContext('input');
-    const output = { summary: 'hello', items: [1, 2, 3] };
-    addStageOutput(ctx, 'my-stage', output);
-
-    const expectedSize = JSON.stringify(output).length;
-    expect(ctx.stageOutputSizes.get('my-stage')).toBe(expectedSize);
-  });
-
-  it('tracks size for each stage independently', () => {
-    const ctx = createInitialContext('input');
-    const out1 = { a: 'short' };
-    const out2 = { b: 'a much longer value here', c: [1, 2, 3, 4, 5] };
-    addStageOutput(ctx, 'stage-1', out1);
-    addStageOutput(ctx, 'stage-2', out2);
-
-    expect(ctx.stageOutputSizes.get('stage-1')).toBe(JSON.stringify(out1).length);
-    expect(ctx.stageOutputSizes.get('stage-2')).toBe(JSON.stringify(out2).length);
-  });
-
-  it('createInitialContext initializes stageOutputSizes as empty map', () => {
-    const ctx = createInitialContext('input');
-    expect(ctx.stageOutputSizes).toBeInstanceOf(Map);
-    expect(ctx.stageOutputSizes.size).toBe(0);
-  });
-});
-
-describe('buildContextKeys', () => {
-  it('returns empty object for empty AgentContext', () => {
-    const ctx: AgentContext = {};
-    expect(buildContextKeys(ctx, new Map())).toEqual({});
-  });
-
-  it('includes input key when additional_context is set', () => {
-    const ctx: AgentContext = { additional_context: 'hello world' };
-    const keys = buildContextKeys(ctx, new Map());
-    expect(keys.input).toBe('hello world'.length);
-  });
-
-  it('includes previous_stage_output with total size from size map', () => {
-    const ctx: AgentContext = {
-      previous_outputs: { 'brief-analysis': { summary: 'ok' } },
-    };
-    const sizes = new Map([['brief-analysis', 42]]);
-    const keys = buildContextKeys(ctx, sizes);
-    expect(keys.previous_stage_output).toBe(42);
-  });
-
-  it('sums sizes for multiple previous outputs', () => {
-    const ctx: AgentContext = {
-      previous_outputs: {
-        'stage-a': { x: 1 },
-        'stage-b': { y: 2 },
-      },
-    };
-    const sizes = new Map([['stage-a', 10], ['stage-b', 20]]);
-    const keys = buildContextKeys(ctx, sizes);
-    expect(keys.previous_stage_output).toBe(30);
-  });
-
-  it('includes group_feedback key', () => {
-    const feedback = { iteration: 1, max_iterations: 3, rejection_reason: 'nope' };
-    const ctx: AgentContext = { group_feedback: feedback };
-    const keys = buildContextKeys(ctx, new Map());
-    expect(keys.group_feedback).toBe(JSON.stringify(feedback).length);
-  });
-
-  it('expands startup_context keys individually', () => {
-    const ctx: AgentContext = {
-      startup_context: {
-        git_status: 'M src/foo.ts',
-        recent_commits: 'abc def',
-      },
-    };
-    const keys = buildContextKeys(ctx, new Map());
-    expect(keys.git_status).toBe('M src/foo.ts'.length);
-    expect(keys.recent_commits).toBe('abc def'.length);
-    expect(keys.input).toBeUndefined();
-  });
-
-  it('includes context packs by name with total section chars', () => {
-    const ctx: AgentContext = {
-      context_packs: [
-        {
-          name: 'api-docs',
-          sections: [
-            { title: 'intro', content: 'hello' },
-            { title: 'details', content: 'world!' },
-          ],
-        },
-      ],
-    };
-    const keys = buildContextKeys(ctx, new Map());
-    expect(keys['api-docs']).toBe('hello'.length + 'world!'.length);
-  });
-
-  it('omits absent keys', () => {
-    const ctx: AgentContext = { additional_context: 'x' };
-    const keys = buildContextKeys(ctx, new Map());
-    expect(Object.keys(keys)).toEqual(['input']);
-  });
-});
-
-const WRITE_TOOL_CALL: ToolCall = {
-  id: '1',
-  name: 'repo_manager-write_file',
-  arguments: { path: 'src/foo.ts', content: 'const x = 1;' },
-  result: { written: true },
-};
-
-describe('buildContextKeys — previous_tool_results', () => {
-  it('includes previous_stage_tool_results key with total serialized byte size', () => {
-    const ctx: AgentContext = { previous_tool_results: { 'code-generation': [WRITE_TOOL_CALL] } };
-    const keys = buildContextKeys(ctx, new Map());
-    expect(keys['previous_stage_tool_results']).toBe(JSON.stringify([WRITE_TOOL_CALL]).length);
-  });
-
-  it('sums sizes across multiple stages', () => {
-    const tc2: ToolCall = { id: '2', name: 'repo_manager-read_file', arguments: { path: 'src/bar.ts' }, result: { path: 'src/bar.ts', content: 'hi' } };
-    const ctx: AgentContext = {
-      previous_tool_results: {
-        'stage-a': [WRITE_TOOL_CALL],
-        'stage-b': [tc2],
-      },
-    };
-    const keys = buildContextKeys(ctx, new Map());
-    expect(keys['previous_stage_tool_results']).toBe(
-      JSON.stringify([WRITE_TOOL_CALL]).length + JSON.stringify([tc2]).length
-    );
-  });
-
-  it('omits previous_stage_tool_results when previous_tool_results is absent', () => {
-    const keys = buildContextKeys({}, new Map());
-    expect(keys['previous_stage_tool_results']).toBeUndefined();
-  });
-
-  it('omits previous_stage_tool_results when previous_tool_results is empty', () => {
-    const keys = buildContextKeys({ previous_tool_results: {} }, new Map());
-    expect(keys['previous_stage_tool_results']).toBeUndefined();
-  });
-});
-
-describe('buildContextContent — previous_tool_results', () => {
-  it('maps previous_stage_tool_results to the previous_tool_results object', () => {
-    const ctx: AgentContext = { previous_tool_results: { 'code-generation': [WRITE_TOOL_CALL] } };
-    expect(buildContextContent(ctx)['previous_stage_tool_results']).toEqual({ 'code-generation': [WRITE_TOOL_CALL] });
-  });
-
-  it('omits previous_stage_tool_results when previous_tool_results is absent', () => {
-    expect(buildContextContent({})['previous_stage_tool_results']).toBeUndefined();
-  });
-
-  it('omits previous_stage_tool_results when previous_tool_results is empty', () => {
-    expect(buildContextContent({ previous_tool_results: {} })['previous_stage_tool_results']).toBeUndefined();
-  });
-});
-
-describe('buildContextContent', () => {
-  it('returns empty object for empty AgentContext', () => {
-    expect(buildContextContent({})).toEqual({});
-  });
-
-  it('maps input key to additional_context value', () => {
-    const ctx: AgentContext = { additional_context: 'my input' };
-    expect(buildContextContent(ctx).input).toBe('my input');
-  });
-
-  it('maps previous_stage_output to previous_outputs object', () => {
-    const ctx: AgentContext = { previous_outputs: { 'stage-a': { x: 1 } } };
-    expect(buildContextContent(ctx).previous_stage_output).toEqual({ 'stage-a': { x: 1 } });
-  });
-
-  it('maps group_feedback key', () => {
-    const fb = { iteration: 1, max_iterations: 3, rejection_reason: 'fail' };
-    const ctx: AgentContext = { group_feedback: fb };
-    expect(buildContextContent(ctx).group_feedback).toEqual(fb);
-  });
-
-  it('expands startup_context keys individually', () => {
-    const ctx: AgentContext = { startup_context: { git_status: 'clean' } };
-    expect(buildContextContent(ctx).git_status).toBe('clean');
-  });
-
-  it('maps each context pack by name to its pack object', () => {
-    const pack = { name: 'api-docs', sections: [{ title: 'h', content: 'c' }] };
-    const ctx: AgentContext = { context_packs: [pack] };
-    expect(buildContextContent(ctx)['api-docs']).toEqual(pack);
-  });
-});

package/src/pipeline/context-propagation.ts

@@ -1,235 +0,0 @@
-// Propagate context between stages
-// Each stage gets the accumulated context from all previous stages
-
-import * as yaml from 'js-yaml';
-import type { StageDefinition, ToolCall } from '@studio-foundation/contracts';
-import type { AgentContext } from '@studio-foundation/runner';
-
-export type PipelineInput = string | Record<string, unknown>;
-
-export interface GroupFeedback {
-  iteration: number;
-  max_iterations: number;
-  rejection_reason: string;
-  rejection_details?: string[];
-}
-
-export interface PipelineContext {
-  input: PipelineInput;
-  stageOutputs: Map<string, unknown>;
-  stageOutputSizes: Map<string, number>;
-  stageToolResults: Map<string, ToolCall[]>;
-  repoPath?: string;
-  groupFeedback?: GroupFeedback;
-  startupContext?: Record<string, string>;
-  invariantsContent?: string;
-}
-
-export function createInitialContext(input: PipelineInput, repoPath?: string): PipelineContext {
-  return {
-    input,
-    stageOutputs: new Map(),
-    stageOutputSizes: new Map(),
-    stageToolResults: new Map(),
-    repoPath,
-  };
-}
-
-export function addStageOutput(
-  context: PipelineContext,
-  stageName: string,
-  output: unknown
-): PipelineContext {
-  context.stageOutputs.set(stageName, output);
-  context.stageOutputSizes.set(stageName, JSON.stringify(output).length);
-  return context;
-}
-
-export function addStageToolResults(
-  context: PipelineContext,
-  stageName: string,
-  toolCalls: ToolCall[]
-): PipelineContext {
-  context.stageToolResults.set(stageName, toolCalls);
-  return context;
-}
-
-export function setGroupFeedback(
-  context: PipelineContext,
-  feedback: GroupFeedback
-): void {
-  context.groupFeedback = feedback;
-}
-
-export function clearGroupFeedback(context: PipelineContext): void {
-  context.groupFeedback = undefined;
-}
-
-export function buildContextKeys(
-  agentContext: AgentContext,
-  previousOutputSizes: Map<string, number>,
-): Record<string, number> {
-  const keys: Record<string, number> = {};
-
-  if (agentContext.additional_context !== undefined) {
-    keys['input'] = agentContext.additional_context.length;
-  }
-
-  if (agentContext.previous_outputs && Object.keys(agentContext.previous_outputs).length > 0) {
-    let total = 0;
-    for (const stageName of Object.keys(agentContext.previous_outputs)) {
-      total += previousOutputSizes.get(stageName) ?? 0;
-    }
-    keys['previous_stage_output'] = total;
-  }
-
-  if (agentContext.group_feedback !== undefined) {
-    keys['group_feedback'] = JSON.stringify(agentContext.group_feedback).length;
-  }
-
-  if (agentContext.startup_context) {
-    for (const [key, value] of Object.entries(agentContext.startup_context)) {
-      keys[key] = value.length;
-    }
-  }
-
-  if (agentContext.context_packs?.length) {
-    for (const pack of agentContext.context_packs) {
-      keys[pack.name] = pack.sections.reduce((sum, s) => sum + s.content.length, 0);
-    }
-  }
-
-  if (agentContext.previous_tool_results && Object.keys(agentContext.previous_tool_results).length > 0) {
-    let total = 0;
-    for (const toolCalls of Object.values(agentContext.previous_tool_results)) {
-      total += JSON.stringify(toolCalls).length;
-    }
-    keys['previous_stage_tool_results'] = total;
-  }
-
-  return keys;
-}
-
-export function buildContextContent(
-  agentContext: AgentContext,
-): Record<string, unknown> {
-  const content: Record<string, unknown> = {};
-
-  if (agentContext.additional_context !== undefined) {
-    content['input'] = agentContext.additional_context;
-  }
-
-  if (agentContext.previous_outputs && Object.keys(agentContext.previous_outputs).length > 0) {
-    content['previous_stage_output'] = agentContext.previous_outputs;
-  }
-
-  if (agentContext.group_feedback !== undefined) {
-    content['group_feedback'] = agentContext.group_feedback;
-  }
-
-  if (agentContext.startup_context) {
-    for (const [key, value] of Object.entries(agentContext.startup_context)) {
-      content[key] = value;
-    }
-  }
-
-  if (agentContext.context_packs?.length) {
-    for (const pack of agentContext.context_packs) {
-      content[pack.name] = pack;
-    }
-  }
-
-  if (agentContext.previous_tool_results && Object.keys(agentContext.previous_tool_results).length > 0) {
-    content['previous_stage_tool_results'] = agentContext.previous_tool_results;
-  }
-
-  return content;
-}
-
-export function getContextForStage(
-  context: PipelineContext,
-  stage: StageDefinition,
-  previousStageName?: string
-): AgentContext {
-  const agentContext: AgentContext = {};
-  const includes = stage.context?.include ?? ['input'];
-
-  for (const include of includes) {
-    switch (include) {
-      case 'input':
-        agentContext.additional_context = typeof context.input === 'string'
-          ? context.input
-          : yaml.dump(context.input, { lineWidth: 120 });
-        break;
-
-      case 'previous_stage_output':
-        if (previousStageName) {
-          const output = context.stageOutputs.get(previousStageName);
-          if (output !== undefined) {
-            agentContext.previous_outputs = {
-              ...agentContext.previous_outputs,
-              [previousStageName]: output,
-            };
-          }
-        }
-        break;
-
-      case 'all_stage_outputs':
-        agentContext.previous_outputs = {
-          ...agentContext.previous_outputs,
-          ...Object.fromEntries(context.stageOutputs),
-        };
-        break;
-
-      case 'stage_name':
-        agentContext.stage_name = stage.name;
-        break;
-
-      case 'group_feedback':
-        if (context.groupFeedback) {
-          agentContext.group_feedback = {
-            iteration: context.groupFeedback.iteration,
-            max_iterations: context.groupFeedback.max_iterations,
-            rejection_reason: context.groupFeedback.rejection_reason,
-            rejection_details: context.groupFeedback.rejection_details,
-          };
-        }
-        break;
-
-      case 'previous_stage_tool_results':
-        if (previousStageName) {
-          const toolResults = context.stageToolResults.get(previousStageName);
-          if (toolResults) {
-            agentContext.previous_tool_results = {
-              ...agentContext.previous_tool_results,
-              [previousStageName]: toolResults,
-            };
-          }
-        }
-        break;
-
-      case 'all_stage_tool_results':
-        if (context.stageToolResults.size > 0) {
-          agentContext.previous_tool_results = {
-            ...agentContext.previous_tool_results,
-            ...Object.fromEntries(context.stageToolResults),
-          };
-        }
-        break;
-
-      case 'repo_files':
-      case 'repo_structure':
-        // Mark that repo files are needed — the engine populates this
-        agentContext.repo_files = agentContext.repo_files ?? [];
-        break;
-
-      case 'pipeline_start_context':
-        if (context.startupContext && Object.keys(context.startupContext).length > 0) {
-          agentContext.startup_context = context.startupContext;
-        }
-        break;
-    }
-  }
-
-  return agentContext;
-}

package/src/pipeline/contract-loader.ts

@@ -1,41 +0,0 @@
-// Load output contracts from YAML files
-
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import * as yaml from 'js-yaml';
-import type { OutputContract } from '@studio-foundation/contracts';
-
-export async function loadContract(
-  name: string,
-  contractsDir: string
-): Promise<OutputContract> {
-  const path = join(contractsDir, `${name}.contract.yaml`);
-
-  let content: string;
-  try {
-    content = await readFile(path, 'utf-8');
-  } catch (err) {
-    throw new Error(`Failed to load contract '${name}' at ${path}: ${(err as Error).message}`);
-  }
-
-  return parseContractYaml(content, path);
-}
-
-export function parseContractYaml(yamlContent: string, sourcePath?: string): OutputContract {
-  const parsed = yaml.load(yamlContent) as Record<string, unknown>;
-  const context = sourcePath ? ` (from ${sourcePath})` : '';
-
-  if (!parsed || typeof parsed !== 'object') {
-    throw new Error(`Invalid contract YAML: expected an object${context}`);
-  }
-
-  if (!parsed.name || typeof parsed.name !== 'string') {
-    throw new Error(`Contract missing required field 'name'${context}`);
-  }
-
-  if (parsed.version === undefined) {
-    throw new Error(`Contract missing required field 'version'${context}`);
-  }
-
-  return parsed as unknown as OutputContract;
-}