vellum 0.2.14 → 0.3.2

package/src/tools/filesystem/edit.ts

@@ -1,127 +0,0 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
-import { FileSystemOps } from '../shared/filesystem/file-ops-service.js';
-import { formatEditDiff } from '../shared/filesystem/format-diff.js';
-import { sandboxPolicy } from '../shared/filesystem/path-policy.js';
-
-class FileEditTool implements Tool {
-  name = 'file_edit';
-  description = 'Replace an exact string in a file with a new string. Use this for surgical edits instead of rewriting entire files.';
-  category = 'filesystem';
-  defaultRiskLevel = RiskLevel.Medium;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          path: {
-            type: 'string',
-            description: 'The path to the file to edit (absolute or relative to working directory)',
-          },
-          old_string: {
-            type: 'string',
-            description: 'The exact text to find in the file',
-          },
-          new_string: {
-            type: 'string',
-            description: 'The replacement text',
-          },
-          replace_all: {
-            type: 'boolean',
-            description: 'Replace all occurrences of old_string instead of requiring a unique match (default: false)',
-          },
-          reason: {
-            type: 'string',
-            description: 'Brief human-readable explanation of why this file is being edited, shown to the user in the permission prompt',
-          },
-        },
-        required: ['path', 'old_string', 'new_string', 'reason'],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const rawPath = input.path as string;
-    if (!rawPath || typeof rawPath !== 'string') {
-      return { content: 'Error: path is required and must be a string', isError: true };
-    }
-
-    const oldString = input.old_string;
-    if (typeof oldString !== 'string') {
-      return { content: 'Error: old_string is required and must be a string', isError: true };
-    }
-
-    const newString = input.new_string;
-    if (typeof newString !== 'string') {
-      return { content: 'Error: new_string is required and must be a string', isError: true };
-    }
-
-    if (oldString.length === 0) {
-      return { content: 'Error: old_string must not be empty', isError: true };
-    }
-
-    if (oldString === newString) {
-      return { content: 'Error: old_string and new_string must be different', isError: true };
-    }
-
-    const replaceAll = input.replace_all === true;
-
-    const ops = new FileSystemOps(
-      (path, opts) => sandboxPolicy(path, context.workingDir, opts),
-    );
-
-    const result = ops.editFileSafe({
-      path: rawPath,
-      oldString,
-      newString,
-      replaceAll,
-    });
-
-    if (!result.ok) {
-      const { error } = result;
-      switch (error.code) {
-        case 'MATCH_NOT_FOUND':
-          return { content: `Error: old_string not found in ${error.path}`, isError: true };
-        case 'MATCH_AMBIGUOUS':
-          return {
-            content: `Error: old_string appears multiple times in ${error.path}. Provide more surrounding context to make it unique, or set replace_all to true.`,
-            isError: true,
-          };
-        case 'IO_ERROR':
-          return { content: `Error editing file: ${error.message}`, isError: true };
-        default:
-          return { content: `Error: ${error.message}`, isError: true };
-      }
-    }
-
-    const { filePath, matchCount, oldContent, newContent, matchMethod, similarity, actualOld, actualNew } = result.value;
-
-    const diffText = formatEditDiff(actualOld, actualNew);
-
-    if (replaceAll) {
-      return {
-        content: `Successfully replaced ${matchCount} occurrence${matchCount > 1 ? 's' : ''} in ${filePath}\n${diffText}`,
-        isError: false,
-        diff: { filePath, oldContent, newContent, isNewFile: false },
-      };
-    }
-
-    const methodNote = matchMethod === 'exact'
-      ? ''
-      : matchMethod === 'whitespace'
-        ? ' (matched with whitespace normalization)'
-        : ` (fuzzy matched, ${Math.round(similarity * 100)}% similar)`;
-    return {
-      content: `Successfully edited ${filePath}${methodNote}\n${diffText}`,
-      isError: false,
-      diff: { filePath, oldContent, newContent, isNewFile: false },
-    };
-  }
-}
-
-registerTool(new FileEditTool());

package/src/tools/filesystem/fuzzy-match.ts

@@ -1,202 +0,0 @@
-export type MatchMethod = 'exact' | 'whitespace' | 'fuzzy';
-
-export interface MatchResult {
-  start: number;
-  end: number;
-  matched: string;
-  similarity: number;
-  method: MatchMethod;
-}
-
-interface IndexedLine {
-  text: string;
-  start: number;
-  end: number;
-}
-
-function levenshtein(a: string, b: string): number {
-  const m = a.length;
-  const n = b.length;
-  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-  for (let i = 0; i <= m; i++) dp[i][0] = i;
-  for (let j = 0; j <= n; j++) dp[0][j] = j;
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      dp[i][j] = a[i - 1] === b[j - 1]
-        ? dp[i - 1][j - 1]
-        : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
-    }
-  }
-  return dp[m][n];
-}
-
-function lineSimilarity(a: string, b: string): number {
-  const maxLen = Math.max(a.length, b.length);
-  if (maxLen === 0) return 1;
-  return 1 - levenshtein(a, b) / maxLen;
-}
-
-function normalizeLines(str: string): string[] {
-  return str.split('\n').map(line => line.trim());
-}
-
-function indexLines(content: string): IndexedLine[] {
-  const lines: IndexedLine[] = [];
-  let pos = 0;
-  for (const text of content.split('\n')) {
-    lines.push({ text, start: pos, end: pos + text.length });
-    pos += text.length + 1; // +1 for the newline
-  }
-  return lines;
-}
-
-function tryExactMatch(content: string, target: string): MatchResult | null {
-  const idx = content.indexOf(target);
-  if (idx === -1) return null;
-  return { start: idx, end: idx + target.length, matched: content.slice(idx, idx + target.length), similarity: 1, method: 'exact' };
-}
-
-function findAllExactMatches(content: string, target: string): MatchResult[] {
-  const results: MatchResult[] = [];
-  let idx = content.indexOf(target);
-  while (idx !== -1) {
-    results.push({ start: idx, end: idx + target.length, matched: content.slice(idx, idx + target.length), similarity: 1, method: 'exact' });
-    idx = content.indexOf(target, idx + 1);
-  }
-  return results;
-}
-
-function tryWhitespaceMatch(contentLines: IndexedLine[], targetNorm: string[]): MatchResult[] {
-  const results: MatchResult[] = [];
-  const windowSize = targetNorm.length;
-  if (windowSize === 0 || contentLines.length < windowSize) return results;
-
-  for (let i = 0; i <= contentLines.length - windowSize; i++) {
-    let allMatch = true;
-    for (let j = 0; j < windowSize; j++) {
-      if (contentLines[i + j].text.trim() !== targetNorm[j]) {
-        allMatch = false;
-        break;
-      }
-    }
-    if (allMatch) {
-      const start = contentLines[i].start;
-      const lastLine = contentLines[i + windowSize - 1];
-      const end = lastLine.end;
-      results.push({
-        start,
-        end,
-        matched: contentLines.slice(i, i + windowSize).map(l => l.text).join('\n'),
-        similarity: 1,
-        method: 'whitespace',
-      });
-    }
-  }
-  return results;
-}
-
-function tryFuzzyMatch(contentLines: IndexedLine[], targetNorm: string[], threshold: number): MatchResult[] {
-  const results: MatchResult[] = [];
-  const windowSize = targetNorm.length;
-  if (windowSize === 0 || contentLines.length < windowSize) return results;
-
-  for (let i = 0; i <= contentLines.length - windowSize; i++) {
-    let totalSimilarity = 0;
-    for (let j = 0; j < windowSize; j++) {
-      totalSimilarity += lineSimilarity(contentLines[i + j].text.trim(), targetNorm[j]);
-    }
-    const avgSimilarity = totalSimilarity / windowSize;
-    if (avgSimilarity >= threshold) {
-      const start = contentLines[i].start;
-      const lastLine = contentLines[i + windowSize - 1];
-      const end = lastLine.end;
-      results.push({
-        start,
-        end,
-        matched: contentLines.slice(i, i + windowSize).map(l => l.text).join('\n'),
-        similarity: avgSimilarity,
-        method: 'fuzzy',
-      });
-    }
-  }
-  return results;
-}
-
-const FUZZY_THRESHOLD = 0.8;
-
-export function findMatch(content: string, target: string): MatchResult | null {
-  if (target.length === 0) return null;
-
-  const exact = tryExactMatch(content, target);
-  if (exact) return exact;
-
-  const contentLines = indexLines(content);
-  const targetNorm = normalizeLines(target);
-
-  const wsMatches = tryWhitespaceMatch(contentLines, targetNorm);
-  if (wsMatches.length === 1) return wsMatches[0];
-  if (wsMatches.length > 1) return wsMatches[0]; // findAllMatches handles ambiguity
-
-  const fuzzyMatches = tryFuzzyMatch(contentLines, targetNorm, FUZZY_THRESHOLD);
-  if (fuzzyMatches.length === 0) return null;
-
-  fuzzyMatches.sort((a, b) => b.similarity - a.similarity);
-  return fuzzyMatches[0];
-}
-
-export function findAllMatches(content: string, target: string): MatchResult[] {
-  if (target.length === 0) return [];
-
-  const exactMatches = findAllExactMatches(content, target);
-  if (exactMatches.length > 0) return exactMatches;
-
-  const contentLines = indexLines(content);
-  const targetNorm = normalizeLines(target);
-
-  const wsMatches = tryWhitespaceMatch(contentLines, targetNorm);
-  if (wsMatches.length > 0) return wsMatches;
-
-  const fuzzyMatches = tryFuzzyMatch(contentLines, targetNorm, FUZZY_THRESHOLD);
-  fuzzyMatches.sort((a, b) => b.similarity - a.similarity);
-  return fuzzyMatches;
-}
-
-function getLeadingWhitespace(line: string): string {
-  const match = line.match(/^(\s*)/);
-  return match ? match[1] : '';
-}
-
-function findFirstNonEmptyLine(str: string): string | null {
-  for (const line of str.split('\n')) {
-    if (line.trim().length > 0) return line;
-  }
-  return null;
-}
-
-export function adjustIndentation(oldString: string, matched: string, newString: string): string {
-  const oldLine = findFirstNonEmptyLine(oldString);
-  const matchedLine = findFirstNonEmptyLine(matched);
-  if (!oldLine || !matchedLine) return newString;
-
-  const oldIndent = getLeadingWhitespace(oldLine);
-  const matchedIndent = getLeadingWhitespace(matchedLine);
-  if (oldIndent === matchedIndent) return newString;
-
-  const oldLen = oldIndent.length;
-  const matchedLen = matchedIndent.length;
-
-  return newString.split('\n').map(line => {
-    if (line.trim().length === 0) return line;
-    const currentIndent = getLeadingWhitespace(line);
-    if (matchedLen > oldLen) {
-      const diff = matchedIndent.slice(0, matchedLen - oldLen);
-      return diff + line;
-    } else {
-      const removeCount = oldLen - matchedLen;
-      if (currentIndent.length >= removeCount) {
-        return line.slice(removeCount);
-      }
-      return line;
-    }
-  }).join('\n');
-}

package/src/tools/filesystem/read.ts

@@ -1,71 +0,0 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
-import { FileSystemOps } from '../shared/filesystem/file-ops-service.js';
-import { sandboxPolicy } from '../shared/filesystem/path-policy.js';
-
-class FileReadTool implements Tool {
-  name = 'file_read';
-  description = 'Read the contents of a file';
-  category = 'filesystem';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          path: {
-            type: 'string',
-            description: 'The path to the file to read (absolute or relative to working directory)',
-          },
-          offset: {
-            type: 'number',
-            description: 'Line number to start reading from (1-indexed)',
-          },
-          limit: {
-            type: 'number',
-            description: 'Maximum number of lines to read',
-          },
-        },
-        required: ['path'],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const rawPath = input.path as string;
-    if (!rawPath || typeof rawPath !== 'string') {
-      return { content: 'Error: path is required and must be a string', isError: true };
-    }
-
-    const ops = new FileSystemOps(
-      (path, opts) => sandboxPolicy(path, context.workingDir, opts),
-    );
-
-    const result = ops.readFileSafe({
-      path: rawPath,
-      offset: typeof input.offset === 'number' ? input.offset : undefined,
-      limit: typeof input.limit === 'number' ? input.limit : undefined,
-    });
-
-    if (!result.ok) {
-      const { error } = result;
-      switch (error.code) {
-        case 'NOT_A_FILE':
-          return { content: `Error: ${error.path} is a directory, not a file`, isError: true };
-        case 'IO_ERROR':
-          return { content: `Error reading file "${rawPath}": ${error.message}`, isError: true };
-        default:
-          return { content: `Error: ${error.message}`, isError: true };
-      }
-    }
-
-    return { content: result.value.content, isError: false };
-  }
-}
-
-registerTool(new FileReadTool());

package/src/tools/filesystem/view-image.ts

@@ -1,199 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { readFileSync, statSync, unlinkSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { extname, join } from 'node:path';
-import { RiskLevel } from '../../permissions/types.js';
-import type { ImageContent, ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
-import { sandboxPolicy } from '../shared/filesystem/path-policy.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-
-const SUPPORTED_EXTENSIONS = new Set([
-  '.jpg', '.jpeg', '.png', '.gif', '.webp',
-]);
-
-const MAX_SIZE_BYTES = 20 * 1024 * 1024; // 20 MB
-
-// Images above this threshold get auto-optimized via sips (macOS) to avoid
-// sending multi-MB base64 payloads to the LLM API.
-const OPTIMIZE_THRESHOLD_BYTES = 1 * 1024 * 1024; // 1 MB
-const OPTIMIZE_MAX_DIMENSION = 1568; // Anthropic's recommended max
-const OPTIMIZE_JPEG_QUALITY = 80;
-
-/**
- * Detect the actual image format from the first bytes of the buffer.
- * Returns the MIME type, or null if unrecognised.
- */
-function detectMediaType(buf: Buffer): string | null {
-  if (buf.length < 12) return null;
-
-  // JPEG: FF D8 FF
-  if (buf[0] === 0xFF && buf[1] === 0xD8 && buf[2] === 0xFF) {
-    return 'image/jpeg';
-  }
-  // PNG: 89 50 4E 47 0D 0A 1A 0A
-  if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4E && buf[3] === 0x47) {
-    return 'image/png';
-  }
-  // GIF: 47 49 46 38
-  if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x38) {
-    return 'image/gif';
-  }
-  // WebP: RIFF....WEBP
-  if (
-    buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46 &&
-    buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50
-  ) {
-    return 'image/webp';
-  }
-
-  return null;
-}
-
-/**
- * Use macOS `sips` to resize and convert an image to JPEG.
- * Returns the path to the optimized temp file, or null if sips is unavailable.
- */
-function optimizeWithSips(srcPath: string): string | null {
-  const tmpPath = join(tmpdir(), `vellum-view-image-${Date.now()}.jpg`);
-  try {
-    execFileSync('sips', [
-      '--resampleHeightWidthMax', String(OPTIMIZE_MAX_DIMENSION),
-      '-s', 'format', 'jpeg',
-      '-s', 'formatOptions', String(OPTIMIZE_JPEG_QUALITY),
-      srcPath,
-      '--out', tmpPath,
-    ], { stdio: 'pipe', timeout: 15_000 });
-    return tmpPath;
-  } catch {
-    return null;
-  }
-}
-
-class ViewImageTool implements Tool {
-  name = 'view_image';
-  description =
-    'Read an image file from the filesystem and return it for visual analysis. Supports JPEG, PNG, GIF, and WebP.';
-  category = 'filesystem';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          path: {
-            type: 'string',
-            description:
-              'The path to the image file (absolute or relative to working directory)',
-          },
-        },
-        required: ['path'],
-      },
-    };
-  }
-
-  async execute(
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolExecutionResult> {
-    const rawPath = input.path as string;
-    if (!rawPath || typeof rawPath !== 'string') {
-      return { content: 'Error: path is required and must be a string', isError: true };
-    }
-
-    const pathCheck = sandboxPolicy(rawPath, context.workingDir);
-    if (!pathCheck.ok) {
-      return { content: `Error: ${pathCheck.error}`, isError: true };
-    }
-    const resolved = pathCheck.resolved;
-
-    const ext = extname(resolved).toLowerCase();
-    if (!SUPPORTED_EXTENSIONS.has(ext)) {
-      const supported = [...SUPPORTED_EXTENSIONS].join(', ');
-      return {
-        content: `Error: unsupported image format "${ext}". Supported: ${supported}`,
-        isError: true,
-      };
-    }
-
-    let stat;
-    try {
-      stat = statSync(resolved);
-    } catch {
-      return { content: `Error: file not found: ${resolved}`, isError: true };
-    }
-
-    if (!stat.isFile()) {
-      return { content: `Error: ${resolved} is not a file`, isError: true };
-    }
-
-    if (stat.size > MAX_SIZE_BYTES) {
-      const sizeMB = (stat.size / (1024 * 1024)).toFixed(1);
-      return {
-        content: `Error: image too large (${sizeMB} MB). Maximum is 20 MB.`,
-        isError: true,
-      };
-    }
-
-    let buffer: Buffer;
-    let optimized = false;
-    let tmpPath: string | null = null;
-
-    try {
-      if (stat.size > OPTIMIZE_THRESHOLD_BYTES) {
-        tmpPath = optimizeWithSips(resolved);
-        if (tmpPath) {
-          buffer = readFileSync(tmpPath) as Buffer;
-          optimized = true;
-        } else {
-          buffer = readFileSync(resolved) as Buffer;
-        }
-      } else {
-        buffer = readFileSync(resolved) as Buffer;
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Error reading file: ${msg}`, isError: true };
-    } finally {
-      if (tmpPath) {
-        try { unlinkSync(tmpPath); } catch { /* ignore cleanup errors */ }
-      }
-    }
-
-    // Detect actual format from magic bytes — never trust the file extension
-    // alone, since sips converts to JPEG and files can be misnamed.
-    const detectedType = detectMediaType(buffer);
-    if (!detectedType) {
-      return {
-        content: `Error: could not detect image format for ${resolved}. The file may be corrupt.`,
-        isError: true,
-      };
-    }
-
-    const base64Data = buffer.toString('base64');
-
-    const imageBlock: ImageContent = {
-      type: 'image' as const,
-      source: {
-        type: 'base64' as const,
-        media_type: detectedType,
-        data: base64Data,
-      },
-    };
-
-    const sizeSuffix = optimized
-      ? ` (optimized from ${(stat.size / 1024).toFixed(0)} KB to ${(buffer.length / 1024).toFixed(0)} KB)`
-      : '';
-
-    return {
-      content: `Image loaded: ${resolved} (${buffer.length} bytes, ${detectedType})${sizeSuffix}`,
-      isError: false,
-      contentBlocks: [imageBlock],
-    };
-  }
-}
-
-registerTool(new ViewImageTool());

package/src/tools/filesystem/write.ts

@@ -1,79 +0,0 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
-import { FileSystemOps } from '../shared/filesystem/file-ops-service.js';
-import { formatWriteSummary } from '../shared/filesystem/format-diff.js';
-import { sandboxPolicy } from '../shared/filesystem/path-policy.js';
-
-class FileWriteTool implements Tool {
-  name = 'file_write';
-  description = 'Write content to a file, creating it if it does not exist';
-  category = 'filesystem';
-  defaultRiskLevel = RiskLevel.Medium;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          path: {
-            type: 'string',
-            description: 'The path to the file to write (absolute or relative to working directory)',
-          },
-          content: {
-            type: 'string',
-            description: 'The content to write to the file',
-          },
-          reason: {
-            type: 'string',
-            description: 'Brief human-readable explanation of why this file is being written, shown to the user in the permission prompt',
-          },
-        },
-        required: ['path', 'content', 'reason'],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const rawPath = input.path as string;
-    if (!rawPath || typeof rawPath !== 'string') {
-      return { content: 'Error: path is required and must be a string', isError: true };
-    }
-
-    const fileContent = input.content;
-    if (typeof fileContent !== 'string') {
-      return { content: 'Error: content is required and must be a string', isError: true };
-    }
-
-    const ops = new FileSystemOps(
-      (path, opts) => sandboxPolicy(path, context.workingDir, opts),
-    );
-
-    const result = ops.writeFileSafe({ path: rawPath, content: fileContent });
-
-    if (!result.ok) {
-      const { error } = result;
-      if (error.code === 'IO_ERROR') {
-        const msg = error.message;
-        const hint = msg.includes('ENOENT') ? ' (parent directory does not exist)'
-          : msg.includes('EACCES') ? ' (permission denied)'
-          : msg.includes('EROFS') ? ' (read-only file system)'
-          : '';
-        return { content: `Error writing file "${rawPath}"${hint}: ${msg}`, isError: true };
-      }
-      return { content: `Error: ${error.message}`, isError: true };
-    }
-
-    const { filePath, oldContent, newContent, isNewFile } = result.value;
-    return {
-      content: `Successfully wrote to ${filePath} ${formatWriteSummary(oldContent, newContent, isNewFile)}`,
-      isError: false,
-      diff: { filePath, oldContent, newContent, isNewFile },
-    };
-  }
-}
-
-registerTool(new FileWriteTool());