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

package/tests/repo-resolver.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
-import { homedir } from 'node:os';
-
-vi.mock('node:child_process', () => ({
-  execSync: vi.fn(),
-}));
-
-vi.mock('node:fs/promises', () => ({
-  mkdir: vi.fn().mockResolvedValue(undefined),
-}));
-
-import { resolveRepoPath, cloneRepo } from '../src/repo-resolver.js';
-import { execSync } from 'node:child_process';
-
-const mockExecSync = vi.mocked(execSync);
-
-afterEach(() => {
-  vi.unstubAllEnvs();
-  mockExecSync.mockClear();
-});
-
-describe('resolveRepoPath', () => {
-  it('returns resolved repoPathOverride when provided', async () => {
-    const result = await resolveRepoPath({ repoPathOverride: 'my-project', pipelineName: 'p' });
-    expect(result).toMatch(/my-project$/);
-  });
-
-  it('returns "." when no repoPathOverride and no repoUrl', async () => {
-    const result = await resolveRepoPath({ pipelineName: 'feature-builder' });
-    expect(result).toBe('.');
-  });
-
-  it('throws when repoUrl is set but no rawProjectsDir and no env var', async () => {
-    vi.stubEnv('STUDIO_PROJECTS_DIR', '');
-    await expect(
-      resolveRepoPath({ repoUrl: 'https://github.com/user/repo', pipelineName: 'p' })
-    ).rejects.toThrow('STUDIO_PROJECTS_DIR is not set');
-  });
-
-  it('clones when repoUrl is provided with rawProjectsDir', async () => {
-    const result = await resolveRepoPath({
-      repoUrl: 'https://github.com/user/repo',
-      rawProjectsDir: '/tmp/projects',
-      pipelineName: 'my-pipeline',
-    });
-    expect(mockExecSync).toHaveBeenCalledOnce();
-    const cmd = mockExecSync.mock.calls[0]![0] as string;
-    expect(cmd).toContain('git clone');
-    expect(cmd).toContain('https://github.com/user/repo');
-    expect(result).toContain('/tmp/projects/my-pipeline-');
-  });
-
-  it('clones when repoUrl is provided via STUDIO_PROJECTS_DIR env var', async () => {
-    vi.stubEnv('STUDIO_PROJECTS_DIR', '/tmp/envprojects');
-    const result = await resolveRepoPath({
-      repoUrl: 'https://github.com/user/repo',
-      pipelineName: 'test-pipe',
-    });
-    expect(mockExecSync).toHaveBeenCalledOnce();
-    expect(result).toContain('/tmp/envprojects/test-pipe-');
-  });
-
-  it('expands ~ in rawProjectsDir', async () => {
-    const result = await resolveRepoPath({
-      repoUrl: 'https://github.com/user/repo',
-      rawProjectsDir: '~/projects',
-      pipelineName: 'p',
-    });
-    expect(result).toContain(homedir() + '/projects/p-');
-  });
-
-  it('repoPathOverride takes precedence over repoUrl', async () => {
-    const result = await resolveRepoPath({
-      repoPathOverride: '/explicit/path',
-      repoUrl: 'https://github.com/user/repo',
-      rawProjectsDir: '/tmp/p',
-      pipelineName: 'p',
-    });
-    expect(result).toBe('/explicit/path');
-    expect(mockExecSync).not.toHaveBeenCalled();
-  });
-
-  it('passes branch arg when branch is set', async () => {
-    await resolveRepoPath({
-      repoUrl: 'https://github.com/user/repo',
-      rawProjectsDir: '/tmp/projects',
-      pipelineName: 'p',
-      branch: 'main',
-    });
-    const cmd = mockExecSync.mock.calls[0]![0] as string;
-    expect(cmd).toContain('--branch main');
-  });
-});
-
-describe('cloneRepo', () => {
-  it('throws a descriptive error when git clone fails', async () => {
-    mockExecSync.mockImplementationOnce(() => { throw new Error('repository not found'); });
-    await expect(
-      cloneRepo('https://github.com/bad/repo', '/tmp/p', 'pipeline')
-    ).rejects.toThrow('Failed to clone https://github.com/bad/repo');
-  });
-});

package/tests/run-store.test.ts

@@ -1,143 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { InMemoryRunStore } from '../src/state/run-store.js';
-import type { PipelineRun } from '@studio-foundation/contracts';
-
-function makePipelineRun(overrides: Partial<PipelineRun> = {}): PipelineRun {
-  return {
-    id: `run-${Math.random().toString(36).slice(2, 8)}`,
-    pipeline_name: 'test-pipeline',
-    status: 'success',
-    started_at: new Date().toISOString(),
-    completed_at: new Date().toISOString(),
-    stages: [],
-    ...overrides,
-  } as PipelineRun;
-}
-
-describe('InMemoryRunStore', () => {
-  let store: InMemoryRunStore;
-
-  beforeEach(() => {
-    store = new InMemoryRunStore();
-  });
-
-  it('saves and retrieves a pipeline run', () => {
-    const run = makePipelineRun({ id: 'run-1' });
-    store.savePipelineRun(run);
-
-    const retrieved = store.getPipelineRun('run-1');
-    expect(retrieved).not.toBeNull();
-    expect(retrieved!.id).toBe('run-1');
-    expect(retrieved!.pipeline_name).toBe('test-pipeline');
-  });
-
-  it('returns null for non-existent run', () => {
-    expect(store.getPipelineRun('nonexistent')).toBeNull();
-  });
-
-  it('returns a clone (not the original reference)', () => {
-    const run = makePipelineRun({ id: 'run-clone' });
-    store.savePipelineRun(run);
-
-    const retrieved = store.getPipelineRun('run-clone');
-    expect(retrieved).not.toBe(run);
-  });
-
-  it('listPipelineRuns returns all runs', () => {
-    store.savePipelineRun(makePipelineRun({ id: 'r1', started_at: '2024-01-01T00:00:00Z' }));
-    store.savePipelineRun(makePipelineRun({ id: 'r2', started_at: '2024-01-02T00:00:00Z' }));
-    store.savePipelineRun(makePipelineRun({ id: 'r3', started_at: '2024-01-03T00:00:00Z' }));
-
-    const runs = store.listPipelineRuns();
-    expect(runs).toHaveLength(3);
-  });
-
-  it('listPipelineRuns sorts by started_at descending', () => {
-    store.savePipelineRun(makePipelineRun({ id: 'r1', started_at: '2024-01-01T00:00:00Z' }));
-    store.savePipelineRun(makePipelineRun({ id: 'r3', started_at: '2024-01-03T00:00:00Z' }));
-    store.savePipelineRun(makePipelineRun({ id: 'r2', started_at: '2024-01-02T00:00:00Z' }));
-
-    const runs = store.listPipelineRuns();
-    expect(runs[0].id).toBe('r3');
-    expect(runs[1].id).toBe('r2');
-    expect(runs[2].id).toBe('r1');
-  });
-
-  it('listPipelineRuns respects limit', () => {
-    store.savePipelineRun(makePipelineRun({ id: 'r1', started_at: '2024-01-01T00:00:00Z' }));
-    store.savePipelineRun(makePipelineRun({ id: 'r2', started_at: '2024-01-02T00:00:00Z' }));
-    store.savePipelineRun(makePipelineRun({ id: 'r3', started_at: '2024-01-03T00:00:00Z' }));
-
-    const runs = store.listPipelineRuns({ limit: 2 });
-    expect(runs).toHaveLength(2);
-  });
-
-  it('listPipelineRuns filters by status', () => {
-    store.savePipelineRun(makePipelineRun({ id: 'r1', status: 'success' }));
-    store.savePipelineRun(makePipelineRun({ id: 'r2', status: 'failed' }));
-    store.savePipelineRun(makePipelineRun({ id: 'r3', status: 'success' }));
-
-    const runs = store.listPipelineRuns({ status: 'failed' });
-    expect(runs).toHaveLength(1);
-    expect(runs[0].id).toBe('r2');
-  });
-
-  it('getLatestRun returns the most recent run', () => {
-    store.savePipelineRun(makePipelineRun({ id: 'r1', started_at: '2024-01-01T00:00:00Z' }));
-    store.savePipelineRun(makePipelineRun({ id: 'r2', started_at: '2024-01-03T00:00:00Z' }));
-    store.savePipelineRun(makePipelineRun({ id: 'r3', started_at: '2024-01-02T00:00:00Z' }));
-
-    const latest = store.getLatestRun();
-    expect(latest).not.toBeNull();
-    expect(latest!.id).toBe('r2');
-  });
-
-  it('getLatestRun filters by pipeline name', () => {
-    store.savePipelineRun(makePipelineRun({
-      id: 'r1',
-      pipeline_name: 'feature-builder',
-      started_at: '2024-01-01T00:00:00Z',
-    }));
-    store.savePipelineRun(makePipelineRun({
-      id: 'r2',
-      pipeline_name: 'other-pipeline',
-      started_at: '2024-01-03T00:00:00Z',
-    }));
-
-    const latest = store.getLatestRun('feature-builder');
-    expect(latest).not.toBeNull();
-    expect(latest!.id).toBe('r1');
-  });
-
-  it('getLatestRun returns null when empty', () => {
-    expect(store.getLatestRun()).toBeNull();
-  });
-
-  it('overwrites existing run on save with same id', () => {
-    const run = makePipelineRun({ id: 'r1', status: 'running' });
-    store.savePipelineRun(run);
-
-    const updated = { ...run, status: 'success' as const, completed_at: new Date().toISOString() };
-    store.savePipelineRun(updated);
-
-    const retrieved = store.getPipelineRun('r1');
-    expect(retrieved!.status).toBe('success');
-  });
-
-  describe('log path', () => {
-    it('returns null for unknown run', () => {
-      expect(store.getLogPath('nonexistent')).toBeNull();
-    });
-
-    it('saves and retrieves a log path', () => {
-      store.saveLogPath('run-1', '/tmp/.studio/runs/log.jsonl');
-      expect(store.getLogPath('run-1')).toBe('/tmp/.studio/runs/log.jsonl');
-    });
-
-    it('overwrites existing log path', () => {
-      store.saveLogPath('run-1', '/tmp/old.jsonl');
-      store.saveLogPath('run-1', '/tmp/new.jsonl');
-      expect(store.getLogPath('run-1')).toBe('/tmp/new.jsonl');
-    });
-  });
-});

package/tests/state-machine.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { isValidTransition, transition } from '../src/state/state-machine.js';
-
-describe('isValidTransition', () => {
-  it('pending → running is valid', () => {
-    expect(isValidTransition('pending', 'running')).toBe(true);
-  });
-
-  it('running → success is valid', () => {
-    expect(isValidTransition('running', 'success')).toBe(true);
-  });
-
-  it('running → failed is valid', () => {
-    expect(isValidTransition('running', 'failed')).toBe(true);
-  });
-
-  it('pending → skipped is valid', () => {
-    expect(isValidTransition('pending', 'skipped')).toBe(true);
-  });
-
-  it('pending → success is INVALID', () => {
-    expect(isValidTransition('pending', 'success')).toBe(false);
-  });
-
-  it('success → running is INVALID', () => {
-    expect(isValidTransition('success', 'running')).toBe(false);
-  });
-
-  it('failed → running is INVALID', () => {
-    expect(isValidTransition('failed', 'running')).toBe(false);
-  });
-
-  it('success → failed is INVALID', () => {
-    expect(isValidTransition('success', 'failed')).toBe(false);
-  });
-
-  it('pending → failed is INVALID', () => {
-    expect(isValidTransition('pending', 'failed')).toBe(false);
-  });
-
-  it('running → rejected is valid', () => {
-    expect(isValidTransition('running', 'rejected')).toBe(true);
-  });
-
-  it('pending → rejected is INVALID', () => {
-    expect(isValidTransition('pending', 'rejected')).toBe(false);
-  });
-
-  it('rejected → running is INVALID', () => {
-    expect(isValidTransition('rejected', 'running')).toBe(false);
-  });
-
-  it('running → cancelled is valid', () => {
-    expect(isValidTransition('running', 'cancelled')).toBe(true);
-  });
-
-  it('pending → cancelled is INVALID', () => {
-    expect(isValidTransition('pending', 'cancelled')).toBe(false);
-  });
-
-  it('cancelled → running is INVALID', () => {
-    expect(isValidTransition('cancelled', 'running')).toBe(false);
-  });
-});
-
-describe('transition', () => {
-  it('pending + start → running', () => {
-    expect(transition('pending', 'start')).toBe('running');
-  });
-
-  it('running + succeed → success', () => {
-    expect(transition('running', 'succeed')).toBe('success');
-  });
-
-  it('running + fail → failed', () => {
-    expect(transition('running', 'fail')).toBe('failed');
-  });
-
-  it('pending + skip → skipped', () => {
-    expect(transition('pending', 'skip')).toBe('skipped');
-  });
-
-  it('pending + succeed throws', () => {
-    expect(() => transition('pending', 'succeed')).toThrow('Invalid state transition');
-  });
-
-  it('success + start throws', () => {
-    expect(() => transition('success', 'start')).toThrow('Invalid state transition');
-  });
-
-  it('failed + succeed throws', () => {
-    expect(() => transition('failed', 'succeed')).toThrow('Invalid state transition');
-  });
-
-  it('running + reject → rejected', () => {
-    expect(transition('running', 'reject')).toBe('rejected');
-  });
-
-  it('pending + reject throws', () => {
-    expect(() => transition('pending', 'reject')).toThrow('Invalid state transition');
-  });
-
-  it('running + cancel → cancelled', () => {
-    expect(transition('running', 'cancel')).toBe('cancelled');
-  });
-
-  it('pending + cancel throws', () => {
-    expect(() => transition('pending', 'cancel')).toThrow('Invalid state transition');
-  });
-});

package/tests/unit/context-propagation.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  getContextForStage,
-  createInitialContext,
-} from '../../src/pipeline/context-propagation.js';
-import type { StageDefinition } from '@studio-foundation/contracts';
-
-const makeStage = (name: string, includes: string[]): StageDefinition => ({
-  name,
-  kind: 'analysis',
-  agent: 'test-agent',
-  context: { include: includes },
-});
-
-describe('getContextForStage — stage_name', () => {
-  it('injects stage_name when included', () => {
-    const ctx = createInitialContext({ userId: 'u1' });
-    const stage = makeStage('recipe-1', ['stage_name']);
-
-    const agentCtx = getContextForStage(ctx, stage);
-
-    expect(agentCtx.stage_name).toBe('recipe-1');
-  });
-
-  it('does not inject stage_name when not included', () => {
-    const ctx = createInitialContext({ userId: 'u1' });
-    const stage = makeStage('recipe-1', ['input']);
-
-    const agentCtx = getContextForStage(ctx, stage);
-
-    expect(agentCtx.stage_name).toBeUndefined();
-  });
-
-  it('injects correct name for each stage', () => {
-    const ctx = createInitialContext('input data');
-    const stages = ['recipe-1', 'recipe-2', 'recipe-5'].map(n =>
-      makeStage(n, ['stage_name'])
-    );
-
-    for (const stage of stages) {
-      const agentCtx = getContextForStage(ctx, stage);
-      expect(agentCtx.stage_name).toBe(stage.name);
-    }
-  });
-});