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

package/src/tools/builtin/git.ts

@@ -1,311 +0,0 @@
-/**
- * Git tools - branch, commit, push, pull, status, diff
- */
-
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import type { Tool } from '../tool-registry.js';
-
-const execAsync = promisify(exec);
-
-const PROTECTED_BRANCHES = ['main', 'master', 'develop', 'production'];
-
-async function isGitRepo(workingDir: string): Promise<boolean> {
-  try {
-    await execAsync('git rev-parse --git-dir', { cwd: workingDir });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function runGit(args: string, workingDir: string): Promise<{ stdout: string; stderr: string }> {
-  return execAsync(`git ${args}`, { cwd: workingDir, timeout: 30000 });
-}
-
-export function createGitTools(workingDir: string): Tool[] {
-  return [
-    {
-      name: 'git-checkout',
-      description: 'Checkout or create a branch',
-      parameters: {
-        type: 'object',
-        properties: {
-          branch: {
-            type: 'string',
-            description: 'Branch name to checkout or create'
-          },
-          create: {
-            type: 'boolean',
-            description: 'Create the branch if it does not exist (-b flag). Default: false'
-          }
-        },
-        required: ['branch']
-      },
-      execute: async ({ branch, create }) => {
-        const branchName = branch as string;
-        const shouldCreate = create as boolean | undefined ?? false;
-
-        if (!(await isGitRepo(workingDir))) {
-          return { success: false, output: null, error: 'Not a git repository' };
-        }
-
-        if (shouldCreate && PROTECTED_BRANCHES.includes(branchName)) {
-          return {
-            success: false,
-            output: null,
-            error: `Cannot create protected branch: ${branchName}`
-          };
-        }
-
-        try {
-          const flag = shouldCreate ? '-b ' : '';
-          const { stdout, stderr } = await runGit(`checkout ${flag}${branchName}`, workingDir);
-          return {
-            success: true,
-            output: { branch: branchName, created: shouldCreate, stdout: stdout.trim(), stderr: stderr.trim() }
-          };
-        } catch (error: unknown) {
-          const e = error as { stderr?: string; message?: string };
-          return {
-            success: false,
-            output: null,
-            error: e.stderr?.trim() || e.message || 'git checkout failed'
-          };
-        }
-      }
-    },
-
-    {
-      name: 'git-commit',
-      description: 'Stage files and commit changes',
-      parameters: {
-        type: 'object',
-        properties: {
-          message: {
-            type: 'string',
-            description: 'Commit message'
-          },
-          files: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Files to stage. If empty or omitted, stages all changes (git add -A)'
-          }
-        },
-        required: ['message']
-      },
-      execute: async ({ message, files }) => {
-        const commitMessage = message as string;
-        const filesToStage = files as string[] | undefined;
-
-        if (!(await isGitRepo(workingDir))) {
-          return { success: false, output: null, error: 'Not a git repository' };
-        }
-
-        try {
-          // Check for merge conflicts
-          const { stdout: statusOut } = await runGit('status --porcelain', workingDir);
-          const hasConflicts = statusOut.split('\n').some(line => line.startsWith('UU') || line.startsWith('AA') || line.startsWith('DD'));
-          if (hasConflicts) {
-            return { success: false, output: null, error: 'Cannot commit: merge conflicts detected' };
-          }
-
-          // Stage files
-          if (filesToStage && filesToStage.length > 0) {
-            await runGit(`add -- ${filesToStage.map(f => `"${f}"`).join(' ')}`, workingDir);
-          } else {
-            await runGit('add -A', workingDir);
-          }
-
-          // Commit
-          const { stdout } = await runGit(`commit -m ${JSON.stringify(commitMessage)}`, workingDir);
-          return {
-            success: true,
-            output: { message: commitMessage, stdout: stdout.trim() }
-          };
-        } catch (error: unknown) {
-          const e = error as { stderr?: string; stdout?: string; message?: string };
-          return {
-            success: false,
-            output: null,
-            error: e.stderr?.trim() || e.stdout?.trim() || e.message || 'git commit failed'
-          };
-        }
-      }
-    },
-
-    {
-      name: 'git-push',
-      description: 'Push current branch to remote',
-      parameters: {
-        type: 'object',
-        properties: {
-          remote: {
-            type: 'string',
-            description: 'Remote name. Default: origin'
-          },
-          set_upstream: {
-            type: 'boolean',
-            description: 'Set upstream tracking (-u flag). Default: true'
-          }
-        },
-        required: []
-      },
-      execute: async ({ remote, set_upstream }) => {
-        const remoteName = (remote as string | undefined) ?? 'origin';
-        const setUpstream = (set_upstream as boolean | undefined) ?? true;
-
-        if (!(await isGitRepo(workingDir))) {
-          return { success: false, output: null, error: 'Not a git repository' };
-        }
-
-        try {
-          const { stdout: branchOut } = await runGit('rev-parse --abbrev-ref HEAD', workingDir);
-          const currentBranch = branchOut.trim();
-
-          const upstreamFlag = setUpstream ? `-u ` : '';
-          const { stdout, stderr } = await runGit(`push ${upstreamFlag}${remoteName} ${currentBranch}`, workingDir);
-          return {
-            success: true,
-            output: { remote: remoteName, branch: currentBranch, stdout: stdout.trim(), stderr: stderr.trim() }
-          };
-        } catch (error: unknown) {
-          const e = error as { stderr?: string; message?: string };
-          return {
-            success: false,
-            output: null,
-            error: e.stderr?.trim() || e.message || 'git push failed'
-          };
-        }
-      }
-    },
-
-    {
-      name: 'git-pull',
-      description: 'Pull latest changes from remote',
-      parameters: {
-        type: 'object',
-        properties: {
-          remote: {
-            type: 'string',
-            description: 'Remote name. Default: origin'
-          },
-          branch: {
-            type: 'string',
-            description: 'Branch to pull. If omitted, pulls current branch'
-          }
-        },
-        required: []
-      },
-      execute: async ({ remote, branch }) => {
-        const remoteName = (remote as string | undefined) ?? 'origin';
-        const branchName = branch as string | undefined;
-
-        if (!(await isGitRepo(workingDir))) {
-          return { success: false, output: null, error: 'Not a git repository' };
-        }
-
-        try {
-          const branchArg = branchName ? ` ${branchName}` : '';
-          const { stdout, stderr } = await runGit(`pull ${remoteName}${branchArg}`, workingDir);
-          return {
-            success: true,
-            output: { remote: remoteName, branch: branchName ?? 'current', stdout: stdout.trim(), stderr: stderr.trim() }
-          };
-        } catch (error: unknown) {
-          const e = error as { stderr?: string; stdout?: string; message?: string };
-          return {
-            success: false,
-            output: null,
-            error: e.stderr?.trim() || e.stdout?.trim() || e.message || 'git pull failed'
-          };
-        }
-      }
-    },
-
-    {
-      name: 'git-status',
-      description: 'Show working tree status (modified, added, deleted files)',
-      parameters: {
-        type: 'object',
-        properties: {},
-        required: []
-      },
-      execute: async () => {
-        if (!(await isGitRepo(workingDir))) {
-          return { success: false, output: null, error: 'Not a git repository' };
-        }
-
-        try {
-          const { stdout: porcelain } = await runGit('status --porcelain', workingDir);
-          const { stdout: branch } = await runGit('rev-parse --abbrev-ref HEAD', workingDir);
-
-          const files = porcelain
-            .split('\n')
-            .filter(line => line.trim())
-            .map(line => ({ status: line.slice(0, 2).trim(), file: line.slice(3) }));
-
-          return {
-            success: true,
-            output: {
-              branch: branch.trim(),
-              clean: files.length === 0,
-              files
-            }
-          };
-        } catch (error: unknown) {
-          const e = error as { stderr?: string; message?: string };
-          return {
-            success: false,
-            output: null,
-            error: e.stderr?.trim() || e.message || 'git status failed'
-          };
-        }
-      }
-    },
-
-    {
-      name: 'git-diff',
-      description: 'Show changes in working tree or staged files',
-      parameters: {
-        type: 'object',
-        properties: {
-          staged: {
-            type: 'boolean',
-            description: 'Show staged changes (--cached). Default: false'
-          },
-          file: {
-            type: 'string',
-            description: 'Diff a specific file. If omitted, shows all changes'
-          }
-        },
-        required: []
-      },
-      execute: async ({ staged, file }) => {
-        const showStaged = (staged as boolean | undefined) ?? false;
-        const filePath = file as string | undefined;
-
-        if (!(await isGitRepo(workingDir))) {
-          return { success: false, output: null, error: 'Not a git repository' };
-        }
-
-        try {
-          const stagedFlag = showStaged ? '--cached ' : '';
-          const fileArg = filePath ? `-- "${filePath}"` : '';
-          const { stdout } = await runGit(`diff ${stagedFlag}${fileArg}`.trim(), workingDir);
-          return {
-            success: true,
-            output: { diff: stdout, staged: showStaged, file: filePath ?? null }
-          };
-        } catch (error: unknown) {
-          const e = error as { stderr?: string; message?: string };
-          return {
-            success: false,
-            output: null,
-            error: e.stderr?.trim() || e.message || 'git diff failed'
-          };
-        }
-      }
-    }
-  ];
-}

package/src/tools/builtin/patch.ts

@@ -1,257 +0,0 @@
-/**
- * Patch tool - apply unified diffs to files
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { Tool, ToolResult } from '../tool-registry.js';
-
-interface Hunk {
-  oldStart: number;
-  oldCount: number;
-  lines: HunkLine[];
-}
-
-interface HunkLine {
-  type: 'context' | 'add' | 'remove';
-  content: string;
-}
-
-interface PatchResult {
-  success: boolean;
-  path: string;
-  hunks_applied: number;
-  hunks_total: number;
-  lines_added: number;
-  lines_removed: number;
-}
-
-/**
- * Parse a unified diff string into hunks.
- */
-function parseHunks(patch: string): Hunk[] {
-  const rawLines = patch.split('\n');
-  // Remove the trailing empty string that split() produces when the patch ends
-  // with '\n'. Without this, the '' is treated as a blank context line and gets
-  // appended to getOldBlock(), causing spurious "Ambiguous match" errors when
-  // the file contains blank lines.
-  if (rawLines.length > 0 && rawLines[rawLines.length - 1] === '') {
-    rawLines.pop();
-  }
-  // Filter out --- / +++ headers
-  const lines = rawLines.filter(
-    (l) => !l.startsWith('---') && !l.startsWith('+++')
-  );
-
-  const hunks: Hunk[] = [];
-  let current: Hunk | null = null;
-
-  for (const line of lines) {
-    const hunkHeader = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+\d+(?:,\d+)?\s*@@/);
-    if (hunkHeader) {
-      current = {
-        oldStart: parseInt(hunkHeader[1], 10),
-        oldCount: parseInt(hunkHeader[2] ?? '1', 10),
-        lines: [],
-      };
-      hunks.push(current);
-      continue;
-    }
-
-    if (!current) continue;
-
-    if (line.startsWith('+')) {
-      current.lines.push({ type: 'add', content: line.slice(1) });
-    } else if (line.startsWith('-')) {
-      current.lines.push({ type: 'remove', content: line.slice(1) });
-    } else if (line.startsWith(' ') || line === '') {
-      // Context line — space prefix or empty line
-      const content = line.startsWith(' ') ? line.slice(1) : line;
-      current.lines.push({ type: 'context', content });
-    }
-    // Ignore lines like ""
-  }
-
-  return hunks;
-}
-
-/**
- * Build the "old block" — context + removed lines that must match the file.
- */
-function getOldBlock(hunk: Hunk): string[] {
-  return hunk.lines
-    .filter((l) => l.type === 'context' || l.type === 'remove')
-    .map((l) => l.content);
-}
-
-/**
- * Build the "new block" — context + added lines that replace the old block.
- */
-function getNewBlock(hunk: Hunk): string[] {
-  return hunk.lines
-    .filter((l) => l.type === 'context' || l.type === 'add')
-    .map((l) => l.content);
-}
-
-/**
- * Compare two strings with trailing whitespace tolerance.
- */
-function fuzzyMatch(a: string, b: string): boolean {
-  return a.trimEnd() === b.trimEnd();
-}
-
-/**
- * Check if oldBlock matches fileLines starting at position `start`.
- */
-function blockMatchesAt(fileLines: string[], oldBlock: string[], start: number): boolean {
-  if (start + oldBlock.length > fileLines.length) return false;
-  return oldBlock.every((line, i) => fuzzyMatch(fileLines[start + i], line));
-}
-
-/**
- * Find where the old block matches in the file.
- * Tries the hinted line first, then scans the full file.
- * Returns the 0-based start index.
- */
-function findMatch(
-  fileLines: string[],
-  oldBlock: string[],
-  hintLine: number,
-  hunkIndex: number
-): number {
-  // Convert 1-based hint to 0-based
-  const hint = hintLine - 1;
-
-  // Pure-insertion hunk: @@ -N,0 ... has no context or removed lines.
-  // Scanning for an empty block would vacuously match every position, so we
-  // insert directly at the hinted position instead.
-  if (oldBlock.length === 0) {
-    return Math.max(0, hint);
-  }
-
-  // Fast path: try at the hinted position
-  if (hint >= 0 && blockMatchesAt(fileLines, oldBlock, hint)) {
-    return hint;
-  }
-
-  // Slow path: scan the whole file
-  const matches: number[] = [];
-  for (let i = 0; i < fileLines.length; i++) {
-    if (blockMatchesAt(fileLines, oldBlock, i)) {
-      matches.push(i);
-    }
-  }
-
-  if (matches.length === 1) return matches[0];
-
-  if (matches.length === 0) {
-    const expected = oldBlock[0] ?? '(empty)';
-    throw new Error(
-      `Context mismatch at hunk ${hunkIndex + 1}: could not find context "${expected}" in file`
-    );
-  }
-
-  throw new Error(
-    `Ambiguous match at hunk ${hunkIndex + 1}: context found at lines ${matches.map((m) => m + 1).join(', ')}. Add more context lines.`
-  );
-}
-
-export function createPatchTools(repoPath: string): Tool[] {
-  return [
-    {
-      name: 'repo_manager-apply_patch',
-      description:
-        'Apply a unified diff patch to a file. The patch must include enough context lines for unambiguous matching. Fails loudly if context doesn\'t match the file content.',
-      parameters: {
-        type: 'object',
-        properties: {
-          path: {
-            type: 'string',
-            description: 'Relative path to the file to patch (from workspace root)',
-          },
-          patch: {
-            type: 'string',
-            description:
-              'Unified diff format patch. Must start with @@ hunk headers. Use - for removed lines, + for added lines, space for context lines. Include at least 3 context lines before and after changes.',
-          },
-        },
-        required: ['path', 'patch'],
-      },
-      execute: async ({ path: filePath, patch: patchStr }): Promise<ToolResult> => {
-        try {
-          const fullPath = path.join(repoPath, filePath as string);
-
-          // Read file
-          let fileContent: string;
-          try {
-            fileContent = await fs.readFile(fullPath, 'utf-8');
-          } catch {
-            return {
-              success: false,
-              output: null,
-              error: `File not found: ${filePath}`,
-            };
-          }
-
-          // Parse hunks
-          const hunks = parseHunks(patchStr as string);
-          if (hunks.length === 0) {
-            return {
-              success: false,
-              output: null,
-              error: 'Invalid patch format: no hunks found (expected @@ headers)',
-            };
-          }
-
-          const fileLines = fileContent.split('\n');
-          let totalAdded = 0;
-          let totalRemoved = 0;
-
-          // Find all match positions first (before any modifications)
-          const matchPositions: number[] = [];
-          for (let i = 0; i < hunks.length; i++) {
-            const oldBlock = getOldBlock(hunks[i]);
-            const pos = findMatch(fileLines, oldBlock, hunks[i].oldStart, i);
-            matchPositions.push(pos);
-          }
-
-          // Apply hunks in reverse order to preserve line numbers
-          const indices = hunks.map((_, i) => i);
-          indices.sort((a, b) => matchPositions[b] - matchPositions[a]);
-
-          for (const i of indices) {
-            const hunk = hunks[i];
-            const pos = matchPositions[i];
-            const oldBlock = getOldBlock(hunk);
-            const newBlock = getNewBlock(hunk);
-
-            fileLines.splice(pos, oldBlock.length, ...newBlock);
-            totalAdded += hunk.lines.filter((l) => l.type === 'add').length;
-            totalRemoved += hunk.lines.filter((l) => l.type === 'remove').length;
-          }
-
-          // Write file back
-          await fs.writeFile(fullPath, fileLines.join('\n'), 'utf-8');
-
-          const result: PatchResult = {
-            success: true,
-            path: filePath as string,
-            hunks_applied: hunks.length,
-            hunks_total: hunks.length,
-            lines_added: totalAdded,
-            lines_removed: totalRemoved,
-          };
-
-          return { success: true, output: result };
-        } catch (error: unknown) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          return {
-            success: false,
-            output: null,
-            error: errorMessage,
-          };
-        }
-      },
-    },
-  ];
-}

package/src/tools/builtin/repo-manager.ts

@@ -1,142 +0,0 @@
-/**
- * Repository manager tools - file operations
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import type { Tool } from '../tool-registry.js';
-
-export function createRepoManagerTools(repoPath: string): Tool[] {
-  return [
-    {
-      name: 'repo_manager-read_file',
-      description: 'Read the contents of a file in the repository',
-      parameters: {
-        type: 'object',
-        properties: {
-          path: {
-            type: 'string',
-            description: 'Relative path to the file from repository root'
-          }
-        },
-        required: ['path']
-      },
-      execute: async ({ path: filePath }) => {
-        try {
-          const fullPath = path.join(repoPath, filePath as string);
-          const content = await fs.readFile(fullPath, 'utf-8');
-          return {
-            success: true,
-            output: { path: filePath, content }
-          };
-        } catch (error: unknown) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          return {
-            success: false,
-            output: null,
-            error: `Failed to read file: ${errorMessage}`
-          };
-        }
-      }
-    },
-    {
-      name: 'repo_manager-write_file',
-      description: 'Write content to a file in the repository (creates or overwrites)',
-      parameters: {
-        type: 'object',
-        properties: {
-          path: {
-            type: 'string',
-            description: 'Relative path to the file from repository root'
-          },
-          content: {
-            type: 'string',
-            description: 'Complete file content to write'
-          }
-        },
-        required: ['path', 'content']
-      },
-      execute: async ({ path: filePath, content }) => {
-        try {
-          const fullPath = path.join(repoPath, filePath as string);
-          const dir = path.dirname(fullPath);
-
-          // Create parent directories if needed
-          await fs.mkdir(dir, { recursive: true });
-
-          // Write file
-          await fs.writeFile(fullPath, content as string, 'utf-8');
-
-          return {
-            success: true,
-            output: { path: filePath, written: true }
-          };
-        } catch (error: unknown) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          return {
-            success: false,
-            output: null,
-            error: `Failed to write file: ${errorMessage}`
-          };
-        }
-      }
-    },
-    {
-      name: 'repo_manager-list_files',
-      description: 'List files in a directory of the repository',
-      parameters: {
-        type: 'object',
-        properties: {
-          path: {
-            type: 'string',
-            description: 'Relative path to the directory (default: root)',
-            default: '.'
-          },
-          recursive: {
-            type: 'boolean',
-            description: 'List files recursively (default: false)',
-            default: false
-          }
-        }
-      },
-      execute: async ({ path: dirPath = '.', recursive = false }) => {
-        try {
-          const fullPath = path.join(repoPath, dirPath as string);
-
-          const files: string[] = [];
-          const ignoredDirs = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage'];
-
-          const listDir = async (currentPath: string, relativeBase: string) => {
-            const entries = await fs.readdir(currentPath, { withFileTypes: true });
-
-            for (const entry of entries) {
-              const relativePath = path.join(relativeBase, entry.name);
-
-              if (entry.isDirectory()) {
-                if (recursive && !ignoredDirs.includes(entry.name)) {
-                  await listDir(path.join(currentPath, entry.name), relativePath);
-                }
-              } else if (entry.isFile()) {
-                files.push(relativePath);
-              }
-            }
-          };
-
-          await listDir(fullPath, '');
-
-          return {
-            success: true,
-            output: { path: dirPath, files, count: files.length }
-          };
-        } catch (error: unknown) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          return {
-            success: false,
-            output: null,
-            error: `Failed to list files: ${errorMessage}`
-          };
-        }
-      }
-    }
-  ];
-}