@studio-foundation/cli 0.3.0-beta.1

package/tests/config.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { writeFile, mkdir, rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { loadConfig, resolveEnvVars } from '../src/config.js';
+
+const TEST_DIR = resolve(import.meta.dirname, '.tmp-config-test');
+
+beforeEach(async () => {
+  await mkdir(TEST_DIR, { recursive: true });
+});
+
+afterEach(async () => {
+  await rm(TEST_DIR, { recursive: true, force: true });
+});
+
+describe('loadConfig', () => {
+  it('should load a valid .studiorc.yaml', async () => {
+    const configPath = resolve(TEST_DIR, '.studiorc.yaml');
+    await writeFile(
+      configPath,
+      `providers:
+  anthropic:
+    apiKey: sk-test-123
+
+paths:
+  pipelines: ./my-pipelines
+
+defaults:
+  provider: anthropic
+`
+    );
+
+    const config = await loadConfig(configPath);
+    expect(config.providers?.anthropic?.apiKey).toBe('sk-test-123');
+    expect(config.paths?.pipelines).toBe('./my-pipelines');
+    expect(config.defaults?.provider).toBe('anthropic');
+  });
+
+  it('should resolve environment variables', async () => {
+    vi.stubEnv('TEST_API_KEY', 'resolved-key-456');
+
+    const configPath = resolve(TEST_DIR, '.studiorc.yaml');
+    await writeFile(
+      configPath,
+      `providers:
+  anthropic:
+    apiKey: \${TEST_API_KEY}
+`
+    );
+
+    const config = await loadConfig(configPath);
+    expect(config.providers?.anthropic?.apiKey).toBe('resolved-key-456');
+
+    vi.unstubAllEnvs();
+  });
+
+  it('should return empty config when file is missing (no explicit path)', async () => {
+    // loadConfig with no argument searches cwd — won't find anything in TEST_DIR
+    const config = await loadConfig();
+    // Should not throw, should return empty-ish config
+    expect(config).toBeDefined();
+  });
+
+  it('should throw on explicitly missing config path', async () => {
+    await expect(
+      loadConfig(resolve(TEST_DIR, 'nonexistent.yaml'))
+    ).rejects.toThrow('Config file not found');
+  });
+
+  it('should throw on malformed YAML', async () => {
+    const configPath = resolve(TEST_DIR, 'bad.yaml');
+    await writeFile(configPath, '{{{{invalid yaml}}}}::: [[[');
+
+    await expect(loadConfig(configPath)).rejects.toThrow('Failed to parse config');
+  });
+
+  it('should load .studio/config.yaml when present', async () => {
+    const studioDir = resolve(TEST_DIR, '.studio');
+    await mkdir(studioDir, { recursive: true });
+    await writeFile(
+      resolve(studioDir, 'config.yaml'),
+      `providers:\n  anthropic:\n    apiKey: studio-key\ndefaults:\n  provider: anthropic\n`
+    );
+    const config = await loadConfig(undefined, TEST_DIR);
+    expect(config.providers?.anthropic?.apiKey).toBe('studio-key');
+    expect(config.resolvedStudioDir).toBe(studioDir);
+  });
+
+  it('should fall back to .studiorc.yaml when no .studio/', async () => {
+    // Mock findStudioDir to return null — simulates a project with no .studio/ in any ancestor.
+    // This avoids environment-specific failures (e.g. ~/.studio/ existing on the runner).
+    vi.doMock('../src/studio-dir.js', () => ({
+      findStudioDir: vi.fn().mockResolvedValue(null),
+    }));
+    vi.resetModules();
+    const { loadConfig: loadConfigFresh } = await import('../src/config.js');
+
+    const isolatedDir = resolve('/tmp', `.studio-config-fallback-${Date.now()}`);
+    await mkdir(isolatedDir, { recursive: true });
+    try {
+      const configPath = resolve(isolatedDir, '.studiorc.yaml');
+      await writeFile(configPath, `providers:\n  openai:\n    apiKey: fallback-key\n`);
+      const config = await loadConfigFresh(undefined, isolatedDir);
+      expect(config.providers?.openai?.apiKey).toBe('fallback-key');
+      expect(config.resolvedStudioDir).toBeUndefined();
+    } finally {
+      await rm(isolatedDir, { recursive: true, force: true });
+      vi.doUnmock('../src/studio-dir.js');
+      vi.resetModules();
+    }
+  });
+
+  it('loadConfig with explicit path ignores .studio/', async () => {
+    const studioDir = resolve(TEST_DIR, '.studio');
+    await mkdir(studioDir, { recursive: true });
+    await writeFile(resolve(studioDir, 'config.yaml'), `providers:\n  anthropic:\n    apiKey: studio-key\n`);
+    const explicit = resolve(TEST_DIR, 'explicit.yaml');
+    await writeFile(explicit, `providers:\n  openai:\n    apiKey: explicit-key\n`);
+    const config = await loadConfig(explicit, TEST_DIR);
+    expect(config.providers?.openai?.apiKey).toBe('explicit-key');
+  });
+});
+
+describe('resolveEnvVars', () => {
+  it('should replace ${VAR} with env value', () => {
+    vi.stubEnv('MY_KEY', 'hello');
+    expect(resolveEnvVars('key: ${MY_KEY}')).toBe('key: hello');
+    vi.unstubAllEnvs();
+  });
+
+  it('should replace missing env vars with empty string', () => {
+    delete process.env['NONEXISTENT_VAR_XYZ'];
+    expect(resolveEnvVars('key: ${NONEXISTENT_VAR_XYZ}')).toBe('key: ');
+  });
+
+  it('should handle multiple env vars', () => {
+    vi.stubEnv('A', '1');
+    vi.stubEnv('B', '2');
+    expect(resolveEnvVars('${A}-${B}')).toBe('1-2');
+    vi.unstubAllEnvs();
+  });
+});

package/tests/formatter.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type { PipelineRun } from '@studio-foundation/contracts';
+import { formatResult, formatJson, formatError, formatDuration } from '../src/output/formatter.js';
+
+let output: string[];
+const originalLog = console.log;
+const originalError = console.error;
+
+beforeEach(() => {
+  output = [];
+  console.log = vi.fn((...args: unknown[]) => {
+    output.push(args.map(String).join(' '));
+  });
+  console.error = vi.fn((...args: unknown[]) => {
+    output.push(args.map(String).join(' '));
+  });
+});
+
+afterEach(() => {
+  console.log = originalLog;
+  console.error = originalError;
+});
+
+function makeRun(overrides: Partial<PipelineRun> = {}): PipelineRun {
+  return {
+    id: 'run-123',
+    pipeline_name: 'test-pipeline',
+    status: 'success',
+    started_at: '2025-01-01T00:00:00.000Z',
+    completed_at: '2025-01-01T00:04:32.000Z',
+    stages: [
+      {
+        id: 'stage-1',
+        stage_name: 'analysis',
+        status: 'success',
+        started_at: '2025-01-01T00:00:00.000Z',
+        completed_at: '2025-01-01T00:01:00.000Z',
+        tasks: [
+          {
+            id: 'task-1',
+            task_name: 'analysis',
+            status: 'success',
+            started_at: '2025-01-01T00:00:00.000Z',
+            completed_at: '2025-01-01T00:01:00.000Z',
+            agent_runs: [
+              {
+                id: 'agent-1',
+                agent_name: 'analyst',
+                attempt: 1,
+                status: 'success',
+                tool_calls: 3,
+                started_at: '2025-01-01T00:00:00.000Z',
+                completed_at: '2025-01-01T00:01:00.000Z',
+              },
+            ],
+          },
+        ],
+      },
+    ],
+    ...overrides,
+  };
+}
+
+describe('formatResult', () => {
+  it('should display success pipeline with stages', () => {
+    const run = makeRun();
+    formatResult(run);
+
+    const text = output.join('\n');
+    expect(text).toContain('test-pipeline');
+    expect(text).toContain('success');
+    expect(text).toContain('analysis');
+    expect(text).toContain('1 attempt');
+  });
+
+  it('should display duration', () => {
+    const run = makeRun();
+    formatResult(run);
+
+    const text = output.join('\n');
+    expect(text).toContain('4m32s');
+  });
+
+  it('should display failed pipeline with error info', () => {
+    const run = makeRun({
+      status: 'failed',
+      stages: [
+        {
+          id: 'stage-1',
+          stage_name: 'code-gen',
+          status: 'failed',
+          started_at: '2025-01-01T00:00:00.000Z',
+          completed_at: '2025-01-01T00:01:00.000Z',
+          tasks: [
+            {
+              id: 'task-1',
+              task_name: 'code-gen',
+              status: 'failed',
+              started_at: '2025-01-01T00:00:00.000Z',
+              completed_at: '2025-01-01T00:01:00.000Z',
+              agent_runs: [
+                {
+                  id: 'agent-1',
+                  agent_name: 'coder',
+                  attempt: 1,
+                  status: 'failed',
+                  tool_calls: 0,
+                  started_at: '2025-01-01T00:00:00.000Z',
+                  completed_at: '2025-01-01T00:01:00.000Z',
+                  error: 'tool_calls = 0: agent did not make any real tool calls',
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+
+    formatResult(run);
+
+    const text = output.join('\n');
+    expect(text).toContain('failed');
+    expect(text).toContain('FAILED');
+    expect(text).toContain('tool_calls = 0');
+  });
+});
+
+describe('formatJson', () => {
+  it('should output pretty JSON', () => {
+    formatJson({ key: 'value' });
+
+    const text = output.join('\n');
+    expect(text).toContain('"key": "value"');
+  });
+});
+
+describe('formatError', () => {
+  it('should output error message', () => {
+    formatError(new Error('something broke'));
+
+    const text = output.join('\n');
+    expect(text).toContain('something broke');
+  });
+});
+
+describe('formatDuration', () => {
+  it('should format sub-second durations', () => {
+    expect(formatDuration(500)).toBe('500ms');
+  });
+
+  it('should format seconds', () => {
+    expect(formatDuration(12000)).toBe('12s');
+  });
+
+  it('should format minutes', () => {
+    expect(formatDuration(83000)).toBe('1m23s');
+  });
+});

package/tests/integration/sigint.test.ts

@@ -0,0 +1,188 @@
+/**
+ * Integration test for SIGINT handling in the CLI.
+ *
+ * Strategy:
+ *  - 2-stage pipeline where stage 1 calls `sleep 60` via the shell tool.
+ *  - After startup, send SIGINT to the process GROUP (kills node + sleep together).
+ *  - SIGINT arrives during sleep: shell tool error → MockProvider returns valid output →
+ *    stage 1 succeeds → engine checks signal.aborted before stage 2 → 'cancelled'.
+ *  - CLI detects status='cancelled' → process.exit(130).
+ *
+ * Regression guard: if the SIGINT handler or AbortController wiring is removed, the
+ * process would exit with 0 or 1 instead of 130.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import { spawn, type ChildProcess } from 'node:child_process';
+import {
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  cpSync,
+  existsSync,
+} from 'node:fs';
+import { resolve, join } from 'node:path';
+
+const CLI_BIN = resolve(import.meta.dirname, '../../dist/index.js');
+
+const SHELL_TOOL_SRC = resolve(
+  import.meta.dirname,
+  '../../../runner/templates/tools/shell.tool.yaml',
+);
+
+function setupProject(dir: string): void {
+  const studioDir = join(dir, '.studio');
+  mkdirSync(join(studioDir, 'pipelines'), { recursive: true });
+  mkdirSync(join(studioDir, 'agents'), { recursive: true });
+  mkdirSync(join(studioDir, 'contracts'), { recursive: true });
+  mkdirSync(join(studioDir, 'tools'), { recursive: true });
+
+  writeFileSync(join(studioDir, 'config.yaml'), [
+    'providers:',
+    '  anthropic:',
+    '    apiKey: test-key',
+    'defaults:',
+    '  provider: anthropic',
+    '  model: claude-sonnet-4-20250514',
+  ].join('\n') + '\n');
+
+  writeFileSync(join(studioDir, 'agents', 'test-agent.agent.yaml'), [
+    'name: test-agent',
+    'provider: anthropic',
+    'model: claude-sonnet-4-20250514',
+    'tools:',
+    '  - shell-run_command',
+  ].join('\n') + '\n');
+
+  // Two contracts — one per stage
+  writeFileSync(join(studioDir, 'contracts', 'slow-stage.contract.yaml'), [
+    'name: slow-stage',
+    'version: 1',
+    'schema:',
+    '  required_fields:',
+    '    - done',
+  ].join('\n') + '\n');
+
+  writeFileSync(join(studioDir, 'contracts', 'fast-stage.contract.yaml'), [
+    'name: fast-stage',
+    'version: 1',
+    'schema:',
+    '  required_fields:',
+    '    - done',
+  ].join('\n') + '\n');
+
+  // Two-stage pipeline: slow (sleep 60 via tool) then fast (instant)
+  writeFileSync(join(studioDir, 'pipelines', 'two-stage.pipeline.yaml'), [
+    'name: two-stage',
+    'version: 2',
+    'stages:',
+    '  - name: slow-stage',
+    '    kind: work',
+    '    agent: test-agent',
+    '    contract: slow-stage',
+    '    ralph:',
+    '      max_attempts: 1',
+    '      retry_strategy: none',
+    '    context:',
+    '      include:',
+    '        - input',
+    '  - name: fast-stage',
+    '    kind: work',
+    '    agent: test-agent',
+    '    contract: fast-stage',
+    '    ralph:',
+    '      max_attempts: 1',
+    '      retry_strategy: none',
+    '    context:',
+    '      include:',
+    '        - input',
+  ].join('\n') + '\n');
+
+  // Mock: slow-stage calls sleep 60, fast-stage is instant (never reached)
+  writeFileSync(join(studioDir, 'mock.yaml'), [
+    'stages:',
+    '  slow-stage:',
+    '    output:',
+    '      done: true',
+    '    tool_calls:',
+    '      - name: shell-run_command',
+    '        arguments:',
+    '          command: "sleep 60"',
+    '  fast-stage:',
+    '    output:',
+    '      done: true',
+    '    tool_calls: []',
+  ].join('\n') + '\n');
+
+  if (existsSync(SHELL_TOOL_SRC)) {
+    cpSync(SHELL_TOOL_SRC, join(studioDir, 'tools', 'shell.tool.yaml'));
+  }
+}
+
+function spawnCli(cwd: string): ChildProcess {
+  return spawn(
+    process.execPath,
+    [CLI_BIN, 'run', 'two-stage', '--provider', 'mock', '--input', 'test'],
+    {
+      cwd,
+      // New process group so the parent test runner is NOT affected by SIGINT
+      detached: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+}
+
+function waitForExit(child: ChildProcess, timeoutMs: number): Promise<{ code: number | null; signal: string | null }> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch { /* already gone */ }
+      reject(new Error(`CLI process did not exit within ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    child.on('exit', (code, signal) => {
+      clearTimeout(timer);
+      resolve({ code, signal });
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+describe('CLI SIGINT handling', () => {
+  let projectDir: string;
+
+  afterEach(() => {
+    if (projectDir) rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it('exits with code 130 on SIGINT during a run', async () => {
+    projectDir = `/tmp/.studio-sigint-test-${Date.now()}`;
+    setupProject(projectDir);
+
+    const child = spawnCli(projectDir);
+
+    // Wait long enough for:
+    //   • Node.js startup + ESM module loading (~500ms)
+    //   • runCommand async setup: loadConfig, createRunStore, loadPipelineByName,
+    //     resolveRepoPath, loadProjectTools, loadPlugins, engine init (~500ms)
+    //   • SIGINT handler registration + engine.run() start (~1ms)
+    //   • sleep 60 tool call to begin executing (a few ms)
+    // 2500ms is 2.5× the measured worst-case setup time → reliable without being slow.
+    await new Promise((r) => setTimeout(r, 2500));
+
+    // Send SIGINT to the entire process group (negative PID = PGID when detached: true).
+    // This kills both node and the sleep subprocess. Node's SIGINT handler fires,
+    // aborts the engine, and the pipeline returns 'cancelled' → process.exit(130).
+    try {
+      process.kill(-(child.pid!), 'SIGINT');
+    } catch {
+      // Process already exited — captured below
+    }
+
+    const { code } = await waitForExit(child, 8000);
+
+    expect(code).toBe(130);
+  }, 15_000);
+});