@studio-foundation/engine 0.3.0-beta.1

package/tests/repo-resolver.test.ts

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,45 @@
+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);
+    }
+  });
+});