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

package/src/pipeline/startup-executor.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { executeStartupCommands } from './startup-executor.js';
-
-describe('executeStartupCommands', () => {
-  it('returns stdout keyed by inject_as', async () => {
-    const result = await executeStartupCommands([
-      { command: 'echo hello', inject_as: 'greeting' },
-      { command: 'echo world', inject_as: 'place' },
-    ]);
-    expect(result.greeting).toBe('hello');
-    expect(result.place).toBe('world');
-  });
-
-  it('skips and warns when a command fails', async () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const result = await executeStartupCommands([
-      { command: 'exit 1', inject_as: 'bad' },
-      { command: 'echo ok', inject_as: 'good' },
-    ]);
-    expect(result.bad).toBeUndefined();
-    expect(result.good).toBe('ok');
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('[on_pipeline_start]'));
-    warnSpy.mockRestore();
-  });
-
-  it('returns empty object when no commands given', async () => {
-    const result = await executeStartupCommands([]);
-    expect(result).toEqual({});
-  });
-
-  it('trims trailing whitespace from stdout', async () => {
-    const result = await executeStartupCommands([
-      { command: 'printf "trimmed"', inject_as: 'val' },
-    ]);
-    expect(result.val).toBe('trimmed');
-  });
-});

package/src/pipeline/startup-executor.ts

@@ -1,32 +0,0 @@
-// Execute on_pipeline_start commands and collect their stdout
-
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import type { StartupCommand } from '@studio-foundation/contracts';
-
-const execAsync = promisify(exec);
-const COMMAND_TIMEOUT_MS = 10_000;
-
-export async function executeStartupCommands(
-  commands: StartupCommand[],
-  cwd?: string
-): Promise<Record<string, string>> {
-  const result: Record<string, string> = {};
-
-  for (const cmd of commands) {
-    try {
-      const { stdout } = await execAsync(cmd.command, {
-        cwd,
-        timeout: COMMAND_TIMEOUT_MS,
-        maxBuffer: 1024 * 1024 * 10,
-      });
-      result[cmd.inject_as] = stdout.trim();
-    } catch (err) {
-      console.warn(
-        `[on_pipeline_start] command failed: "${cmd.command}" — ${(err as Error).message}`
-      );
-    }
-  }
-
-  return result;
-}

package/src/pipeline/types.ts

@@ -1,42 +0,0 @@
-// engine/src/pipeline/types.ts
-// Shared local types for pipeline execution — used by engine, StageExecutor, GroupOrchestrator
-
-import { join } from 'node:path';
-import type { StageRun, StageStatus, ToolCall } from '@studio-foundation/contracts';
-import type { PostValidationResult } from './post-validator.js';
-import type { PipelineContext } from './context-propagation.js';
-
-export interface ProjectPaths {
-  projectDir: string;
-  pipelinesDir: string;
-  agentsDir: string;
-  contractsDir: string;
-}
-
-export function resolveProjectPaths(configsDir: string): ProjectPaths {
-  return {
-    projectDir: configsDir,
-    pipelinesDir: join(configsDir, 'pipelines'),
-    agentsDir: join(configsDir, 'agents'),
-    contractsDir: join(configsDir, 'contracts'),
-  };
-}
-
-export interface StageResult {
-  stageRun: StageRun;
-  status: StageStatus;
-  postValidation?: PostValidationResult;
-  lastAgentOutput?: unknown;
-  toolCalls?: ToolCall[];
-  tokensDelta?: number;       // tokens consumed by this stage
-  toolCallsDelta?: number;    // tool calls made by this stage
-}
-
-export interface GroupResult {
-  status: StageStatus;
-  stageRuns: StageRun[];
-  stagesExecuted: number;
-  context: PipelineContext;
-  totalTokensDelta: number;
-  totalToolCallsDelta: number;
-}

package/src/repo-resolver.ts

@@ -1,61 +0,0 @@
-import { execSync } from 'node:child_process';
-import { mkdir } from 'node:fs/promises';
-import { resolve, join } from 'node:path';
-import { homedir } from 'node:os';
-
-export interface RepoResolveOptions {
-  repoPathOverride?: string;
-  repoUrl?: string;
-  rawProjectsDir?: string;
-  pipelineName: string;
-  branch?: string;
-}
-
-export async function cloneRepo(
-  repoUrl: string,
-  projectsDir: string,
-  pipelineName: string,
-  branch?: string
-): Promise<string> {
-  await mkdir(projectsDir, { recursive: true });
-
-  const timestamp = new Date().toISOString()
-    .replace(/:/g, 'h')
-    .replace(/\..+$/, '')
-    .replace('T', 'T');
-  const dirName = `${pipelineName}-${timestamp}`;
-  const clonePath = join(projectsDir, dirName);
-
-  const branchArg = branch ? `--branch ${branch}` : '';
-  const cmd = `git clone --depth 1 ${branchArg} ${repoUrl} ${clonePath}`;
-
-  try {
-    execSync(cmd, { stdio: 'pipe' });
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to clone ${repoUrl}: ${msg}`);
-  }
-
-  return clonePath;
-}
-
-export async function resolveRepoPath(options: RepoResolveOptions): Promise<string> {
-  const { repoPathOverride, repoUrl, rawProjectsDir, pipelineName, branch } = options;
-
-  if (repoPathOverride) {
-    return resolve(repoPathOverride);
-  }
-
-  if (repoUrl) {
-    const rawDir = rawProjectsDir || process.env['STUDIO_PROJECTS_DIR'];
-    const projectsDir = rawDir?.replace(/^~/, homedir());
-    if (!projectsDir) {
-      throw new Error(
-        'STUDIO_PROJECTS_DIR is not set. Set it in config.yaml paths.projects_dir or as an environment variable.'
-      );
-    }
-    return cloneRepo(repoUrl, projectsDir, pipelineName, branch);
-  }
-
-  return '.';
-}

package/src/spawners/direct-engine-spawner.ts

@@ -1,26 +0,0 @@
-import type { RunSpawner, SpawnConfig, SpawnResult, PipelineRun } from '@studio-foundation/contracts';
-import { PipelineEngine, type EngineConfig } from '../engine.js';
-
-export class DirectEngineSpawner implements RunSpawner {
-  constructor(private engineConfig: EngineConfig) {}
-
-  async spawnAndWait(config: SpawnConfig): Promise<SpawnResult> {
-    const child = new PipelineEngine(this.engineConfig);
-    const result: PipelineRun = await child.run({
-      pipeline: config.pipeline,
-      input: config.input,
-      parentRunId: config.parentRunId,
-      depth: config.depth,
-    });
-
-    if (result.status === 'failed' || result.status === 'rejected' || result.status === 'cancelled') {
-      throw new Error(`Child run ${result.id} ${result.status}`);
-    }
-
-    // Extract output from the last successful stage
-    const lastStage = [...result.stages].reverse().find(s => s.status === 'success');
-    const output = (lastStage as { output?: unknown } | undefined)?.output ?? null;
-
-    return { run_id: result.id, status: result.status, output };
-  }
-}

package/src/state/run-store.test.ts

@@ -1,157 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { SQLiteRunStore, PgRunStore } from './run-store.js';
-import type { PipelineRun } from '@studio-foundation/contracts';
-
-function makeRun(overrides?: Partial<PipelineRun>): PipelineRun {
-  return {
-    id: 'run-1',
-    pipeline_name: 'test-pipeline',
-    status: 'running',
-    started_at: '2026-01-01T00:00:00.000Z',
-    stages: [],
-    ...overrides,
-  };
-}
-
-describe('SQLiteRunStore', () => {
-  describe('saveLogPath / getLogPath', () => {
-    it('returns null when no log path has been set', () => {
-      const store = new SQLiteRunStore(':memory:');
-      store.savePipelineRun(makeRun());
-      expect(store.getLogPath('run-1')).toBeNull();
-    });
-
-    it('returns the log path after saveLogPath', () => {
-      const store = new SQLiteRunStore(':memory:');
-      store.savePipelineRun(makeRun());
-      store.saveLogPath('run-1', '/tmp/run-1.jsonl');
-      expect(store.getLogPath('run-1')).toBe('/tmp/run-1.jsonl');
-    });
-
-    it('preserves log_path when savePipelineRun is called again after saveLogPath', () => {
-      // Regression for STU-150: savePipelineRun used INSERT OR REPLACE which clobbers log_path
-      const store = new SQLiteRunStore(':memory:');
-      store.savePipelineRun(makeRun());
-      store.saveLogPath('run-1', '/tmp/run-1.jsonl');
-
-      // Simulate engine completing the run (this triggered the bug)
-      store.savePipelineRun(makeRun({ status: 'success', completed_at: '2026-01-01T00:01:00.000Z' }));
-
-      expect(store.getLogPath('run-1')).toBe('/tmp/run-1.jsonl');
-    });
-
-    it('returns null for unknown run id', () => {
-      const store = new SQLiteRunStore(':memory:');
-      expect(store.getLogPath('does-not-exist')).toBeNull();
-    });
-  });
-
-  describe('parent_run_id', () => {
-    it('persists and retrieves parent_run_id', () => {
-      const run: PipelineRun = {
-        id: 'child-123',
-        pipeline_name: 'child-pipe',
-        status: 'success',
-        started_at: new Date().toISOString(),
-        stages: [],
-        parent_run_id: 'parent-456',
-      };
-      const store = new SQLiteRunStore(':memory:');
-      store.savePipelineRun(run);
-      const retrieved = store.getPipelineRun('child-123');
-      expect(retrieved?.parent_run_id).toBe('parent-456');
-    });
-  });
-});
-
-const TEST_PG_URL = process.env.TEST_DATABASE_URL;
-
-describe.skipIf(!TEST_PG_URL)('PgRunStore', () => {
-  let store: PgRunStore;
-
-  beforeEach(async () => {
-    store = new PgRunStore(TEST_PG_URL!);
-    await store.dangerouslyTruncateForTests();
-  });
-
-  afterEach(async () => {
-    await store.close();
-  });
-
-  it('saves and retrieves a pipeline run', async () => {
-    const run = makePgRun('pg-run-1');
-    await store.savePipelineRun(run);
-    const found = await store.getPipelineRun('pg-run-1');
-    expect(found).toMatchObject({ id: 'pg-run-1', status: 'success' });
-  });
-
-  it('returns null for unknown id', async () => {
-    const found = await store.getPipelineRun('doesnt-exist');
-    expect(found).toBeNull();
-  });
-
-  it('updates an existing run (upsert)', async () => {
-    const run = makePgRun('pg-run-2');
-    await store.savePipelineRun(run);
-    await store.savePipelineRun({ ...run, status: 'failed' });
-    const found = await store.getPipelineRun('pg-run-2');
-    expect(found?.status).toBe('failed');
-  });
-
-  it('lists runs with status filter', async () => {
-    await store.savePipelineRun(makePgRun('pg-1', 'success'));
-    await store.savePipelineRun(makePgRun('pg-2', 'failed'));
-    const successes = await store.listPipelineRuns({ status: 'success' });
-    expect(successes).toHaveLength(1);
-    expect(successes[0].id).toBe('pg-1');
-  });
-
-  it('lists runs with limit', async () => {
-    for (let i = 0; i < 5; i++) {
-      await store.savePipelineRun(makePgRun(`pg-limit-${i}`));
-    }
-    const runs = await store.listPipelineRuns({ limit: 3 });
-    expect(runs).toHaveLength(3);
-  });
-
-  it('getLatestRun returns most recent', async () => {
-    await store.savePipelineRun(makePgRun('pg-old', 'success', '2024-01-01T00:00:00Z'));
-    await store.savePipelineRun(makePgRun('pg-new', 'success', '2024-06-01T00:00:00Z'));
-    const latest = await store.getLatestRun();
-    expect(latest?.id).toBe('pg-new');
-  });
-
-  it('getLatestRun filters by pipeline name', async () => {
-    await store.savePipelineRun(makePgRun('pg-a', 'success', undefined, 'pipeline-a'));
-    await store.savePipelineRun(makePgRun('pg-b', 'success', undefined, 'pipeline-b'));
-    const latest = await store.getLatestRun('pipeline-a');
-    expect(latest?.id).toBe('pg-a');
-  });
-
-  it('saves and retrieves log path', async () => {
-    await store.savePipelineRun(makePgRun('pg-log-1'));
-    await store.saveLogPath('pg-log-1', '/tmp/test.jsonl');
-    const path = await store.getLogPath('pg-log-1');
-    expect(path).toBe('/tmp/test.jsonl');
-  });
-
-  it('returns null log path for unknown run', async () => {
-    const path = await store.getLogPath('no-such-run');
-    expect(path).toBeNull();
-  });
-});
-
-function makePgRun(
-  id: string,
-  status: string = 'success',
-  startedAt: string = new Date().toISOString(),
-  pipelineName: string = 'test-pipeline'
-) {
-  return {
-    id,
-    pipeline_name: pipelineName,
-    status,
-    started_at: startedAt,
-    stages: [],
-  } as PipelineRun;
-}