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

package/src/tools/builtin/search.ts

@@ -1,108 +0,0 @@
-/**
- * Search tool - codebase search using grep
- */
-
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import type { Tool } from '../tool-registry.js';
-
-const execAsync = promisify(exec);
-
-export function createSearchTools(repoPath: string): Tool[] {
-  return [
-    {
-      name: 'search-search_codebase',
-      description: 'Search for a pattern in the codebase (like grep)',
-      parameters: {
-        type: 'object',
-        properties: {
-          pattern: {
-            type: 'string',
-            description: 'Search pattern (string or regex)'
-          },
-          file_pattern: {
-            type: 'string',
-            description: 'File glob pattern to filter (e.g., "*.ts", "*.js")',
-          }
-        },
-        required: ['pattern']
-      },
-      execute: async ({ pattern, file_pattern }) => {
-        try {
-          const pat = pattern as string;
-          const filePat = file_pattern as string | undefined;
-
-          // Try ripgrep first, fallback to grep
-          let command: string;
-
-          // Check if ripgrep is available
-          try {
-            await execAsync('which rg', { cwd: repoPath });
-            // Use ripgrep
-            command = filePat
-              ? `rg -n --glob "${filePat}" "${pat}" .`
-              : `rg -n "${pat}" .`;
-          } catch {
-            // Fallback to standard grep
-            command = filePat
-              ? `grep -r -n --include="${filePat}" "${pat}" .`
-              : `grep -r -n "${pat}" .`;
-          }
-
-          const { stdout } = await execAsync(command, {
-            cwd: repoPath,
-            maxBuffer: 1024 * 1024 * 10, // 10MB
-            timeout: 30000
-          });
-
-          // Parse results - format is "file:line:content"
-          const lines = stdout.trim().split('\n').filter(l => l.length > 0);
-          const matches = lines.slice(0, 50).map(line => {
-            const parts = line.split(':');
-            if (parts.length >= 3) {
-              const [file, lineNum, ...rest] = parts;
-              return {
-                file,
-                line: parseInt(lineNum, 10),
-                content: rest.join(':').trim()
-              };
-            }
-            return null;
-          }).filter(m => m !== null);
-
-          return {
-            success: true,
-            output: {
-              pattern,
-              matches,
-              count: matches.length,
-              total_found: lines.length,
-              truncated: lines.length > 50
-            }
-          };
-        } catch (error: unknown) {
-          // Exit code 1 typically means no matches found
-          if (error && typeof error === 'object' && 'code' in error && error.code === 1) {
-            return {
-              success: true,
-              output: {
-                pattern,
-                matches: [],
-                count: 0,
-                total_found: 0,
-                truncated: false
-              }
-            };
-          }
-
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          return {
-            success: false,
-            output: null,
-            error: `Search failed: ${errorMessage}`
-          };
-        }
-      }
-    }
-  ];
-}

package/src/tools/builtin/shell.ts

@@ -1,82 +0,0 @@
-/**
- * Shell tool - command execution with basic safety checks
- */
-
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import type { Tool } from '../tool-registry.js';
-
-const execAsync = promisify(exec);
-
-export function createShellTools(workingDir: string): Tool[] {
-  return [
-    {
-      name: 'shell-run_command',
-      description: 'Run a shell command in the repository directory',
-      parameters: {
-        type: 'object',
-        properties: {
-          command: {
-            type: 'string',
-            description: 'The shell command to run'
-          }
-        },
-        required: ['command']
-      },
-      execute: async ({ command }) => {
-        try {
-          const cmd = command as string;
-
-          // Basic sanitization - block obviously dangerous commands
-          const dangerous = ['rm -rf', 'sudo', 'mkfs', 'dd if=', '> /dev/', 'format'];
-          const isDangerous = dangerous.some(pattern => cmd.toLowerCase().includes(pattern));
-
-          if (isDangerous) {
-            return {
-              success: false,
-              output: null,
-              error: 'Dangerous command blocked for safety'
-            };
-          }
-
-          // Execute with timeout of 30 seconds
-          const { stdout, stderr } = await execAsync(cmd, {
-            cwd: workingDir,
-            timeout: 30000,
-            maxBuffer: 1024 * 1024 * 10 // 10MB max output
-          });
-
-          return {
-            success: true,
-            output: {
-              stdout: stdout.trim(),
-              stderr: stderr.trim(),
-              exitCode: 0
-            }
-          };
-        } catch (error: unknown) {
-          // Execution error (non-zero exit code or timeout)
-          if (error && typeof error === 'object' && 'stdout' in error && 'stderr' in error) {
-            const execError = error as { stdout: string; stderr: string; code?: number };
-            return {
-              success: false,
-              output: {
-                stdout: execError.stdout?.trim() || '',
-                stderr: execError.stderr?.trim() || '',
-                exitCode: execError.code || 1
-              },
-              error: execError.stderr?.trim() || 'Command execution failed'
-            };
-          }
-
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          return {
-            success: false,
-            output: null,
-            error: `Shell execution error: ${errorMessage}`
-          };
-        }
-      }
-    }
-  ];
-}

package/src/tools/builtin/studio-run.ts

@@ -1,73 +0,0 @@
-import type { RunSpawner } from '@studio-foundation/contracts';
-import type { Tool } from '../tool-registry.js';
-
-interface StudioRunContext {
-  spawner: RunSpawner;
-  currentRunId: string;
-  currentDepth: number;
-  maxDepth: number;
-}
-
-export const STUDIO_RUN_PROMPT_SNIPPET = `
-## studio_run tool
-
-Use \`studio_run-run_pipeline\` to launch a Studio pipeline run and wait for its result.
-The run executes asynchronously but this tool blocks until completion.
-Use it to orchestrate sub-pipelines (e.g. generate N items by launching N runs).
-`.trim();
-
-export function createStudioRunTool(ctx: StudioRunContext): Tool[] {
-  return [
-    {
-      name: 'studio_run-run_pipeline',
-      description: 'Launch a Studio pipeline run and wait for completion. Returns the output of the last stage.',
-      parameters: {
-        type: 'object',
-        properties: {
-          pipeline: {
-            type: 'string',
-            description: 'Name of the pipeline to run (e.g. "recipe-developer")',
-          },
-          input: {
-            type: 'object',
-            description: 'Input data for the pipeline',
-          },
-          wait: {
-            type: 'boolean',
-            description: 'Whether to wait for completion before returning (default: true)',
-            default: true,
-          },
-        },
-        required: ['pipeline', 'input'],
-      },
-      async execute(args) {
-        const pipeline = args['pipeline'] as string;
-        const input = args['input'] as Record<string, unknown>;
-        const wait = args['wait'] !== false;
-
-        if (!wait) {
-          throw new Error('wait: false is not supported in v1. Use wait: true (default).');
-        }
-
-        if (ctx.currentDepth + 1 > ctx.maxDepth) {
-          throw new Error(
-            `studio-run depth limit reached (max: ${ctx.maxDepth}). ` +
-            `Current depth: ${ctx.currentDepth}. Recursive pipeline spawning is not allowed at this level.`
-          );
-        }
-
-        const result = await ctx.spawner.spawnAndWait({
-          pipeline,
-          input,
-          parentRunId: ctx.currentRunId,
-          depth: ctx.currentDepth + 1,
-        });
-
-        return {
-          success: result.status === 'success',
-          output: result,
-        };
-      },
-    },
-  ];
-}

package/src/tools/builtin/web-search.test.ts

@@ -1,122 +0,0 @@
-/**
- * Tests for the web_search builtin tool
- */
-
-import { describe, it, expect, vi, afterEach } from 'vitest';
-import { createWebSearchTools, WEB_SEARCH_PROMPT_SNIPPET } from './web-search.js';
-
-describe('createWebSearchTools', () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-    delete process.env.TAVILY_API_KEY;
-  });
-
-  it('returns a single tool named web_search-search', () => {
-    const tools = createWebSearchTools();
-    expect(tools).toHaveLength(1);
-    expect(tools[0].name).toBe('web_search-search');
-  });
-
-  it('requires query parameter', () => {
-    const [tool] = createWebSearchTools();
-    const schema = tool.parameters as { required: string[] };
-    expect(schema.required).toContain('query');
-  });
-
-  it('returns error when TAVILY_API_KEY is not set', async () => {
-    const [tool] = createWebSearchTools();
-    const result = await tool.execute({ query: 'test' });
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/TAVILY_API_KEY/);
-  });
-
-  it('calls Tavily API and returns results', async () => {
-    process.env.TAVILY_API_KEY = 'test-key';
-    const mockResponse = {
-      results: [
-        { title: 'Result 1', url: 'https://example.com/1', content: 'Content 1', score: 0.9 },
-        { title: 'Result 2', url: 'https://example.com/2', content: 'Content 2', score: 0.8 },
-      ],
-      answer: 'A direct answer'
-    };
-
-    vi.spyOn(global, 'fetch').mockResolvedValueOnce(
-      new Response(JSON.stringify(mockResponse), { status: 200 })
-    );
-
-    const [tool] = createWebSearchTools();
-    const result = await tool.execute({ query: 'test query', max_results: 2 });
-
-    expect(result.success).toBe(true);
-    const output = result.output as {
-      query: string;
-      results: Array<{ title: string; url: string }>;
-      answer: string;
-      count: number;
-    };
-    expect(output.query).toBe('test query');
-    expect(output.results).toHaveLength(2);
-    expect(output.results[0].title).toBe('Result 1');
-    expect(output.answer).toBe('A direct answer');
-    expect(output.count).toBe(2);
-  });
-
-  it('passes max_results to Tavily API', async () => {
-    process.env.TAVILY_API_KEY = 'test-key';
-    vi.spyOn(global, 'fetch').mockResolvedValueOnce(
-      new Response(JSON.stringify({ results: [], answer: null }), { status: 200 })
-    );
-
-    const [tool] = createWebSearchTools();
-    await tool.execute({ query: 'test', max_results: 3 });
-
-    const [, options] = (fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit];
-    const body = JSON.parse(options.body as string);
-    expect(body.max_results).toBe(3);
-  });
-
-  it('defaults max_results to 5 when not provided', async () => {
-    process.env.TAVILY_API_KEY = 'test-key';
-    vi.spyOn(global, 'fetch').mockResolvedValueOnce(
-      new Response(JSON.stringify({ results: [] }), { status: 200 })
-    );
-
-    const [tool] = createWebSearchTools();
-    await tool.execute({ query: 'test' });
-
-    const [, options] = (fetch as ReturnType<typeof vi.fn>).mock.calls[0] as [string, RequestInit];
-    const body = JSON.parse(options.body as string);
-    expect(body.max_results).toBe(5);
-  });
-
-  it('returns error on non-ok API response', async () => {
-    process.env.TAVILY_API_KEY = 'test-key';
-    vi.spyOn(global, 'fetch').mockResolvedValueOnce(
-      new Response('Unauthorized', { status: 401 })
-    );
-
-    const [tool] = createWebSearchTools();
-    const result = await tool.execute({ query: 'test' });
-
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/401/);
-  });
-
-  it('returns error on network failure', async () => {
-    process.env.TAVILY_API_KEY = 'test-key';
-    vi.spyOn(global, 'fetch').mockRejectedValueOnce(new Error('Network error'));
-
-    const [tool] = createWebSearchTools();
-    const result = await tool.execute({ query: 'test' });
-
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/Network error/);
-  });
-});
-
-describe('WEB_SEARCH_PROMPT_SNIPPET', () => {
-  it('is a non-empty string', () => {
-    expect(typeof WEB_SEARCH_PROMPT_SNIPPET).toBe('string');
-    expect(WEB_SEARCH_PROMPT_SNIPPET.length).toBeGreaterThan(0);
-  });
-});

package/src/tools/builtin/web-search.ts

@@ -1,101 +0,0 @@
-/**
- * Web search tool - search the web using the Tavily API
- */
-
-import type { Tool } from '../tool-registry.js';
-
-const TAVILY_API_URL = 'https://api.tavily.com/search';
-
-export const WEB_SEARCH_PROMPT_SNIPPET = `
-## web_search tool
-
-Use \`web_search-search\` to search the web for up-to-date information.
-Search in the language most relevant to the query (e.g. English for technical docs, French for local content).
-Prefer specific, targeted queries over broad ones for better results.
-`.trim();
-
-export function createWebSearchTools(): Tool[] {
-  return [
-    {
-      name: 'web_search-search',
-      description: 'Search the web using Tavily and return relevant results',
-      parameters: {
-        type: 'object',
-        properties: {
-          query: {
-            type: 'string',
-            description: 'The search query'
-          },
-          max_results: {
-            type: 'number',
-            description: 'Maximum number of results to return (default: 5)'
-          }
-        },
-        required: ['query']
-      },
-      execute: async ({ query, max_results }) => {
-        const apiKey = process.env.TAVILY_API_KEY;
-        if (!apiKey) {
-          return {
-            success: false,
-            output: null,
-            error: 'TAVILY_API_KEY environment variable is not set'
-          };
-        }
-
-        const q = query as string;
-        const limit = (max_results as number | undefined) ?? 5;
-
-        try {
-          const response = await fetch(TAVILY_API_URL, {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'Authorization': `Bearer ${apiKey}`
-            },
-            body: JSON.stringify({
-              query: q,
-              max_results: limit
-            })
-          });
-
-          if (!response.ok) {
-            const text = await response.text();
-            return {
-              success: false,
-              output: null,
-              error: `Tavily API error ${response.status}: ${text}`
-            };
-          }
-
-          const data = await response.json() as {
-            results?: Array<{ title: string; url: string; content: string; score?: number }>;
-            answer?: string;
-          };
-
-          return {
-            success: true,
-            output: {
-              query: q,
-              results: (data.results ?? []).map(r => ({
-                title: r.title,
-                url: r.url,
-                content: r.content,
-                score: r.score
-              })),
-              answer: data.answer ?? null,
-              count: (data.results ?? []).length
-            }
-          };
-        } catch (error: unknown) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          return {
-            success: false,
-            output: null,
-            error: `Web search failed: ${errorMessage}`
-          };
-        }
-      }
-    }
-  ];
-}

package/src/tools/errors.test.ts

@@ -1,12 +0,0 @@
-// runner/src/tools/errors.test.ts
-import { describe, it, expect } from 'vitest';
-import { ToolYamlError } from './errors.js';
-
-describe('ToolYamlError', () => {
-  it('is an Error with name ToolYamlError', () => {
-    const err = new ToolYamlError('bad yaml');
-    expect(err).toBeInstanceOf(Error);
-    expect(err.name).toBe('ToolYamlError');
-    expect(err.message).toBe('bad yaml');
-  });
-});

package/src/tools/errors.ts

@@ -1,6 +0,0 @@
-export class ToolYamlError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'ToolYamlError';
-  }
-}

package/src/tools/plugin-loader.test.ts

@@ -1,130 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { loadProjectTools } from './plugin-loader.js';
-import { ToolYamlError } from './errors.js';
-
-let tmpDir: string;
-
-beforeAll(async () => {
-  tmpDir = await mkdtemp(join(tmpdir(), 'studio-tool-loader-test-'));
-});
-
-afterAll(async () => {
-  await rm(tmpDir, { recursive: true, force: true });
-});
-
-async function writeToolYaml(name: string, content: string): Promise<string> {
-  const dir = join(tmpDir, name);
-  await mkdir(dir, { recursive: true });
-  const toolsDir = join(dir, 'tools');
-  await mkdir(toolsDir, { recursive: true });
-  await writeFile(join(toolsDir, `${name}.tool.yaml`), content);
-  return toolsDir;
-}
-
-describe('loadProjectTools — shell template validation', () => {
-  it('throws ToolYamlError when template uses undeclared placeholder', async () => {
-    const toolsDir = await writeToolYaml('bad-search', `
-name: bad_search
-version: 1
-commands:
-  - name: bad_search-search
-    description: Search
-    parameters:
-      query:
-        type: string
-        required: true
-    execute:
-      type: shell
-      command: 'curl "https://api.example.com?q={{search_query}}"'
-`);
-    const promise = loadProjectTools(toolsDir, '/tmp');
-    await expect(promise).rejects.toThrow(ToolYamlError);
-    await expect(promise).rejects.toThrow(ToolYamlError);
-    await expect(promise).rejects.toThrow(
-      "template uses {{search_query}} but no such parameter is declared"
-    );
-  });
-
-  it('loads successfully when all template placeholders are declared', async () => {
-    const toolsDir = await writeToolYaml('good-search', `
-name: good_search
-version: 1
-commands:
-  - name: good_search-search
-    description: Search
-    parameters:
-      query:
-        type: string
-        required: true
-    execute:
-      type: shell
-      command: 'curl "https://api.example.com?q={{query}}"'
-`);
-    await expect(loadProjectTools(toolsDir, '/tmp')).resolves.toHaveLength(1);
-  });
-
-  it('does not flag {{else}} as an undeclared placeholder', async () => {
-    const toolsDir = await writeToolYaml('conditional-tool', `
-name: conditional_tool
-version: 1
-commands:
-  - name: conditional_tool-run
-    description: Run with optional flag
-    parameters:
-      verbose:
-        type: boolean
-        required: false
-    execute:
-      type: shell
-      command: 'echo {{#if verbose}}--verbose{{else}}--quiet{{/if}}'
-`);
-    await expect(loadProjectTools(toolsDir, '/tmp')).resolves.toHaveLength(1);
-  });
-
-  it('error message includes filename, command name, and declared parameters', async () => {
-    const toolsDir = await writeToolYaml('err-msg', `
-name: err_msg
-version: 1
-commands:
-  - name: err_msg-run
-    description: Run
-    parameters:
-      query:
-        type: string
-        required: true
-    execute:
-      type: shell
-      command: 'curl {{typo}}'
-`);
-    const promise = loadProjectTools(toolsDir, '/tmp');
-    await expect(promise).rejects.toThrow(ToolYamlError);
-    await expect(promise).rejects.toThrow(
-      "err-msg.tool.yaml › command 'err_msg-run'"
-    );
-    await expect(promise).rejects.toThrow(
-      "Declared parameters: query"
-    );
-  });
-
-  it('error message shows (none) when command has no parameters declared', async () => {
-    const toolsDir = await writeToolYaml('no-params', `
-name: no_params
-version: 1
-commands:
-  - name: no_params-run
-    description: Run
-    parameters: {}
-    execute:
-      type: shell
-      command: 'curl {{typo}}'
-`);
-    const promise = loadProjectTools(toolsDir, '/tmp');
-    await expect(promise).rejects.toThrow(ToolYamlError);
-    await expect(promise).rejects.toThrow(
-      "Declared parameters: (none)"
-    );
-  });
-});