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

package/tests/studio-run.test.ts

@@ -1,94 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createStudioRunTool } from '../src/tools/builtin/studio-run.js';
-import type { RunSpawner } from '@studio-foundation/contracts';
-
-function makeSpawner(overrides?: Partial<RunSpawner>): RunSpawner {
-  return {
-    spawnAndWait: vi.fn().mockResolvedValue({
-      run_id: 'child-abc',
-      status: 'success',
-      output: { result: 'done' },
-    }),
-    ...overrides,
-  };
-}
-
-describe('createStudioRunTool', () => {
-  it('returns a tool named studio_run-run_pipeline', () => {
-    const tools = createStudioRunTool({
-      spawner: makeSpawner(),
-      currentRunId: 'parent-1',
-      currentDepth: 0,
-      maxDepth: 3,
-    });
-    expect(tools).toHaveLength(1);
-    expect(tools[0].name).toBe('studio_run-run_pipeline');
-  });
-
-  it('throws depth limit error before calling spawner', async () => {
-    const spawner = makeSpawner();
-    const tools = createStudioRunTool({
-      spawner,
-      currentRunId: 'parent-1',
-      currentDepth: 3,  // already at max
-      maxDepth: 3,
-    });
-    const tool = tools[0];
-    await expect(
-      tool.execute({ pipeline: 'my-pipe', input: { x: 1 }, wait: true })
-    ).rejects.toThrow('studio-run depth limit reached (max: 3)');
-    expect(spawner.spawnAndWait).not.toHaveBeenCalled();
-  });
-
-  it('calls spawner with correct config and returns result', async () => {
-    const spawner = makeSpawner();
-    const tools = createStudioRunTool({
-      spawner,
-      currentRunId: 'parent-1',
-      currentDepth: 0,
-      maxDepth: 3,
-    });
-    const result = await tools[0].execute({
-      pipeline: 'recipe-developer',
-      input: { dish: 'pasta' },
-      wait: true,
-    });
-    expect(spawner.spawnAndWait).toHaveBeenCalledWith({
-      pipeline: 'recipe-developer',
-      input: { dish: 'pasta' },
-      parentRunId: 'parent-1',
-      depth: 1,
-    });
-    expect(result).toEqual({
-      success: true,
-      output: { run_id: 'child-abc', status: 'success', output: { result: 'done' } },
-    });
-  });
-
-  it('propagates error when spawner throws', async () => {
-    const spawner = makeSpawner({
-      spawnAndWait: vi.fn().mockRejectedValue(new Error('Child run child-abc failed: contract violation')),
-    });
-    const tools = createStudioRunTool({
-      spawner,
-      currentRunId: 'parent-1',
-      currentDepth: 0,
-      maxDepth: 3,
-    });
-    await expect(
-      tools[0].execute({ pipeline: 'bad-pipe', input: {}, wait: true })
-    ).rejects.toThrow('Child run child-abc failed');
-  });
-
-  it('throws when wait is false (not supported in v1)', async () => {
-    const tools = createStudioRunTool({
-      spawner: makeSpawner(),
-      currentRunId: 'parent-1',
-      currentDepth: 0,
-      maxDepth: 3,
-    });
-    await expect(
-      tools[0].execute({ pipeline: 'x', input: {}, wait: false })
-    ).rejects.toThrow('wait: false is not supported');
-  });
-});

package/tests/tool-executor.test.ts

@@ -1,115 +0,0 @@
-/**
- * Tool executor tests
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { ToolExecutor } from '../src/tools/tool-executor.js';
-import { ToolRegistry, type Tool } from '../src/tools/tool-registry.js';
-
-describe('ToolExecutor', () => {
-  let registry: ToolRegistry;
-  let executor: ToolExecutor;
-
-  beforeEach(() => {
-    registry = new ToolRegistry();
-    executor = new ToolExecutor(registry);
-  });
-
-  it('should execute a successful tool call', async () => {
-    // Register a test tool
-    const testTool: Tool = {
-      name: 'test_tool',
-      description: 'A test tool',
-      parameters: {
-        type: 'object',
-        properties: { foo: { type: 'string' } },
-      },
-      execute: async (args) => ({
-        success: true,
-        output: { result: 'hello world', args }
-      })
-    };
-    registry.register(testTool);
-
-    // Execute the tool
-    const result = await executor.execute({
-      id: 'test-1',
-      name: 'test_tool',
-      arguments: { foo: 'bar' }
-    });
-
-    expect(result).toEqual({
-      id: 'test-1',
-      name: 'test_tool',
-      arguments: { foo: 'bar' },
-      result: { result: 'hello world', args: { foo: 'bar' } }
-    });
-  });
-
-  it('should handle tool not found', async () => {
-    const result = await executor.execute({
-      id: 'test-1',
-      name: 'unknown_tool',
-      arguments: {}
-    });
-
-    expect(result).toEqual({
-      id: 'test-1',
-      name: 'unknown_tool',
-      arguments: {},
-      error: 'Tool not found: unknown_tool'
-    });
-  });
-
-  it('should handle tool execution failure', async () => {
-    const failingTool: Tool = {
-      name: 'failing_tool',
-      description: 'A tool that fails',
-      parameters: {},
-      execute: async () => ({
-        success: false,
-        output: null,
-        error: 'Something went wrong'
-      })
-    };
-    registry.register(failingTool);
-
-    const result = await executor.execute({
-      id: 'test-1',
-      name: 'failing_tool',
-      arguments: {}
-    });
-
-    expect(result).toEqual({
-      id: 'test-1',
-      name: 'failing_tool',
-      arguments: {},
-      error: 'Something went wrong'
-    });
-  });
-
-  it('should handle tool that throws exception', async () => {
-    const throwingTool: Tool = {
-      name: 'throwing_tool',
-      description: 'A tool that throws',
-      parameters: {},
-      execute: async () => {
-        throw new Error('Unexpected error');
-      }
-    };
-    registry.register(throwingTool);
-
-    const result = await executor.execute({
-      id: 'test-1',
-      name: 'throwing_tool',
-      arguments: {}
-    });
-
-    expect(result).toEqual({
-      id: 'test-1',
-      name: 'throwing_tool',
-      arguments: {},
-      error: 'Unexpected error'
-    });
-  });
-});

package/tests/tool-registry.test.ts

@@ -1,84 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ToolRegistry } from '../src/tools/tool-registry.js';
-
-function makeTool(name: string) {
-  return {
-    name,
-    description: `Tool ${name}`,
-    parameters: {},
-    execute: async () => ({ success: true as const, output: null }),
-  };
-}
-
-describe('ToolRegistry.registerPlugin', () => {
-  it('registers all tools in a plugin', () => {
-    const registry = new ToolRegistry();
-    registry.registerPlugin('my_plugin', [makeTool('my_plugin-foo'), makeTool('my_plugin-bar')]);
-    expect(registry.has('my_plugin-foo')).toBe(true);
-    expect(registry.has('my_plugin-bar')).toBe(true);
-  });
-
-  it('stores the prompt snippet for retrieval', () => {
-    const registry = new ToolRegistry();
-    registry.registerPlugin('my_plugin', [makeTool('my_plugin-foo')], 'Use foo carefully.');
-    expect(registry.getActiveSnippets()).toEqual(['Use foo carefully.']);
-  });
-
-  it('getActiveSnippets returns empty when no snippets registered', () => {
-    const registry = new ToolRegistry();
-    registry.registerPlugin('my_plugin', [makeTool('my_plugin-foo')]);
-    expect(registry.getActiveSnippets()).toEqual([]);
-  });
-});
-
-describe('ToolRegistry.filter preserves snippet metadata', () => {
-  it('filtered registry returns snippet for included tools', () => {
-    const registry = new ToolRegistry();
-    registry.registerPlugin('plug_a', [makeTool('plug_a-foo')], 'Snippet A');
-    registry.registerPlugin('plug_b', [makeTool('plug_b-bar')], 'Snippet B');
-
-    const filtered = registry.filter(['plug_a-foo']);
-    expect(filtered.getActiveSnippets()).toEqual(['Snippet A']);
-  });
-
-  it('filtered registry does not return snippet for excluded tools', () => {
-    const registry = new ToolRegistry();
-    registry.registerPlugin('plug_a', [makeTool('plug_a-foo')], 'Snippet A');
-    registry.registerPlugin('plug_b', [makeTool('plug_b-bar')], 'Snippet B');
-
-    const filtered = registry.filter(['plug_a-foo']);
-    expect(filtered.getActiveSnippets()).not.toContain('Snippet B');
-  });
-
-  it('normalizes dot-notation in filter with snippets', () => {
-    const registry = new ToolRegistry();
-    registry.registerPlugin('repo_manager', [makeTool('repo_manager-write_file')], 'Write files!');
-    const filtered = registry.filter(['repo_manager.write_file']);
-    expect(filtered.getActiveSnippets()).toEqual(['Write files!']);
-  });
-});
-
-describe('clone', () => {
-  it('creates an independent copy with all tools', () => {
-    const registry = new ToolRegistry();
-    registry.registerPlugin('my_plugin', [
-      { name: 'my_plugin-cmd', description: 'test', parameters: {}, execute: async () => ({ content: 'ok' }) },
-    ], 'my snippet');
-
-    const clone = registry.clone();
-    expect(clone.get('my_plugin-cmd')).toBeDefined();
-    expect(clone.getActiveSnippets()).toContain('my snippet');
-  });
-
-  it('mutations to clone do not affect original', () => {
-    const registry = new ToolRegistry();
-    registry.registerPlugin('original', [
-      { name: 'original-cmd', description: 'test', parameters: {}, execute: async () => ({ content: 'ok' }) },
-    ]);
-    const clone = registry.clone();
-    clone.registerPlugin('extra', [
-      { name: 'extra-cmd', description: 'test', parameters: {}, execute: async () => ({ content: 'ok' }) },
-    ]);
-    expect(registry.get('extra-cmd')).toBeUndefined();
-  });
-});

package/tests/yaml-executor.test.ts

@@ -1,76 +0,0 @@
-// runner/tests/yaml-executor.test.ts
-import { describe, it, expect } from 'vitest';
-import { renderTemplate, executeShellCommand } from '../src/tools/yaml-executor.js';
-
-describe('renderTemplate', () => {
-  it('substitutes plain {{param}}', () => {
-    expect(renderTemplate('echo {{message}}', { message: 'hello' })).toBe('echo hello');
-  });
-
-  it('renders {{#if param}}...{{/if}} when truthy', () => {
-    expect(renderTemplate('git diff {{#if staged}}--cached{{/if}}', { staged: true }))
-      .toBe('git diff --cached');
-  });
-
-  it('removes {{#if param}}...{{/if}} block when falsy', () => {
-    expect(renderTemplate('git diff {{#if staged}}--cached{{/if}}', { staged: false }))
-      .toBe('git diff ');
-  });
-
-  it('renders {{#if param}}...{{/if}} when param is absent', () => {
-    expect(renderTemplate('git diff {{#if staged}}--cached{{/if}}', {}))
-      .toBe('git diff ');
-  });
-
-  it('joins array with {{param | join sep}}', () => {
-    expect(renderTemplate('git add {{files | join " "}}', { files: ['a.ts', 'b.ts'] }))
-      .toBe('git add a.ts b.ts');
-  });
-
-  it('renders {{param | json}} as JSON string', () => {
-    expect(renderTemplate('echo {{data | json}}', { data: ['a', 'b'] }))
-      .toBe('echo ["a","b"]');
-  });
-
-  it('returns empty string for missing plain param', () => {
-    expect(renderTemplate('{{missing}}', {})).toBe('');
-  });
-
-  it('handles multi-line templates', () => {
-    const template = `{{#if create}}
-git checkout -b {{branch}}
-{{else}}
-git checkout {{branch}}
-{{/if}}`;
-    // Note: we don't support {{else}} yet — it stays as literal text
-    // Just ensure it doesn't crash and substitutes {{branch}}
-    const result = renderTemplate(template, { create: false, branch: 'main' });
-    expect(result).toContain('main');
-  });
-});
-
-describe('executeShellCommand', () => {
-  it('executes a command and returns stdout as text', async () => {
-    const result = await executeShellCommand('echo hello', 'text', '/tmp');
-    expect(result.success).toBe(true);
-    expect(result.output).toBe('hello');
-  });
-
-  it('parses JSON output when parse_output is json', async () => {
-    const result = await executeShellCommand('echo \'{"x":1}\'', 'json', '/tmp');
-    expect(result.success).toBe(true);
-    expect(result.output).toEqual({ x: 1 });
-  });
-
-  it('returns error on non-zero exit code', async () => {
-    const result = await executeShellCommand('exit 1', 'text', '/tmp');
-    expect(result.success).toBe(false);
-    expect(result.error).toBeDefined();
-  });
-
-  it('returns error when JSON parsing fails', async () => {
-    const result = await executeShellCommand('echo not-json', 'json', '/tmp');
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/Failed to parse JSON/);
-  });
-});

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "node"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
-}

package/vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    exclude: ['dist/**', 'node_modules/**'],
-  },
-});