@vibe-lang/runtime 0.2.5

package/src/runtime/stdlib/edit.test.ts

@@ -0,0 +1,154 @@
+// Tests for the edit tool
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { edit } from './tools';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const TEST_DIR = path.join(__dirname, '.test-workspace-edit');
+
+describe('edit tool', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  test('basic replacement - oldText replaced with newText', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const x = 1;\nconst y = 2;');
+
+    await edit.executor(
+      {
+        path: filePath,
+        oldText: 'const x = 1;',
+        newText: 'const x = 42;',
+      },
+      { rootDir: TEST_DIR }
+    );
+
+    const result = fs.readFileSync(filePath, 'utf-8');
+    expect(result).toBe('const x = 42;\nconst y = 2;');
+  });
+
+  test('multiline replacement', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(
+      filePath,
+      `function foo() {
+  return 1;
+}
+
+function bar() {
+  return 2;
+}`
+    );
+
+    await edit.executor(
+      {
+        path: filePath,
+        oldText: `function foo() {
+  return 1;
+}`,
+        newText: `function foo() {
+  return 42;
+}`,
+      },
+      { rootDir: TEST_DIR }
+    );
+
+    const result = fs.readFileSync(filePath, 'utf-8');
+    expect(result).toContain('return 42;');
+    expect(result).toContain('function bar()');
+  });
+
+  test('error: oldText not found', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const x = 1;');
+
+    await expect(
+      edit.executor(
+        {
+          path: filePath,
+          oldText: 'NOT_FOUND',
+          newText: 'replacement',
+        },
+        { rootDir: TEST_DIR }
+      )
+    ).rejects.toThrow('oldText not found in file');
+  });
+
+  test('error: oldText matches multiple times', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const x = 1;\nconst x = 1;');
+
+    await expect(
+      edit.executor(
+        {
+          path: filePath,
+          oldText: 'const x = 1;',
+          newText: 'const x = 42;',
+        },
+        { rootDir: TEST_DIR }
+      )
+    ).rejects.toThrow('oldText matches 2 times, must match exactly once');
+  });
+
+  test('replaces empty string with content (prepend)', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'content');
+
+    // This actually replaces the first empty string match
+    // which prepends to the file
+    await edit.executor(
+      {
+        path: filePath,
+        oldText: 'content',
+        newText: 'new content',
+      },
+      { rootDir: TEST_DIR }
+    );
+
+    const result = fs.readFileSync(filePath, 'utf-8');
+    expect(result).toBe('new content');
+  });
+
+  test('handles special characters in oldText', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const regex = /test.*end/;');
+
+    await edit.executor(
+      {
+        path: filePath,
+        oldText: 'const regex = /test.*end/;',
+        newText: 'const regex = /new/;',
+      },
+      { rootDir: TEST_DIR }
+    );
+
+    const result = fs.readFileSync(filePath, 'utf-8');
+    expect(result).toBe('const regex = /new/;');
+  });
+
+  test('preserves file encoding and line endings', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    const content = 'line1\r\nline2\r\nline3';
+    fs.writeFileSync(filePath, content);
+
+    await edit.executor(
+      {
+        path: filePath,
+        oldText: 'line2',
+        newText: 'modified',
+      },
+      { rootDir: TEST_DIR }
+    );
+
+    const result = fs.readFileSync(filePath, 'utf-8');
+    expect(result).toBe('line1\r\nmodified\r\nline3');
+  });
+});

package/src/runtime/stdlib/fastEdit.test.ts

@@ -0,0 +1,201 @@
+// Tests for stdlib tools
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { fastEdit } from './tools';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const TEST_DIR = path.join(__dirname, '.test-workspace');
+
+describe('fastEdit tool', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  test('basic replacement - prefix...suffix replaced with newText', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(
+      filePath,
+      `function foo() {
+  console.log("old");
+  return 1;
+}
+
+function bar() {
+  return 2;
+}`
+    );
+
+    await fastEdit.executor(
+      {
+        path: filePath,
+        prefix: 'function foo() {',
+        suffix: 'return 1;\n}',
+        newText: `function foo() {
+  console.log("new");
+  return 42;
+}`,
+      },
+      { rootDir: TEST_DIR }
+    );
+
+    const result = fs.readFileSync(filePath, 'utf-8');
+    expect(result).toContain('console.log("new")');
+    expect(result).toContain('return 42;');
+    expect(result).toContain('function bar()'); // Other function unchanged
+  });
+
+  test('non-greedy matching - stops at first suffix after prefix', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    // Two functions that end with "return result;"
+    fs.writeFileSync(
+      filePath,
+      `function first() {
+  return result;
+}
+
+function second() {
+  return result;
+}`
+    );
+
+    await fastEdit.executor(
+      {
+        path: filePath,
+        prefix: 'function first() {',
+        suffix: 'return result;\n}',
+        newText: `function first() {
+  return "replaced";
+}`,
+      },
+      { rootDir: TEST_DIR }
+    );
+
+    const result = fs.readFileSync(filePath, 'utf-8');
+    expect(result).toContain('return "replaced"');
+    expect(result).toContain('function second()'); // Second function unchanged
+    // Second function should still have original return
+    expect(result).toMatch(/function second\(\) \{\s+return result;/);
+  });
+
+  test('error: prefix not found', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const x = 1;');
+
+    await expect(
+      fastEdit.executor(
+        {
+          path: filePath,
+          prefix: 'function notFound() {',
+          suffix: '}',
+          newText: 'replacement',
+        },
+        { rootDir: TEST_DIR }
+      )
+    ).rejects.toThrow('no region found matching prefix...suffix');
+  });
+
+  test('error: suffix not found after prefix', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'function foo() { return 1; }');
+
+    await expect(
+      fastEdit.executor(
+        {
+          path: filePath,
+          prefix: 'function foo() {',
+          suffix: 'NOT_FOUND_SUFFIX',
+          newText: 'replacement',
+        },
+        { rootDir: TEST_DIR }
+      )
+    ).rejects.toThrow('no region found matching prefix...suffix');
+  });
+
+  test('error: multiple matches (ambiguous anchors)', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    // Two identical functions - ambiguous!
+    fs.writeFileSync(
+      filePath,
+      `function foo() {
+  return 1;
+}
+
+function foo() {
+  return 1;
+}`
+    );
+
+    await expect(
+      fastEdit.executor(
+        {
+          path: filePath,
+          prefix: 'function foo() {',
+          suffix: 'return 1;\n}',
+          newText: 'replacement',
+        },
+        { rootDir: TEST_DIR }
+      )
+    ).rejects.toThrow('2 regions match, must match exactly once');
+  });
+
+  test('special regex characters in prefix/suffix are escaped', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    // Content with regex special characters
+    fs.writeFileSync(filePath, 'const pattern = /test.*?end/; // comment');
+
+    await fastEdit.executor(
+      {
+        path: filePath,
+        prefix: 'const pattern = /test.*?end/',
+        suffix: '// comment',
+        newText: 'const pattern = /new/; // updated',
+      },
+      { rootDir: TEST_DIR }
+    );
+
+    const result = fs.readFileSync(filePath, 'utf-8');
+    expect(result).toBe('const pattern = /new/; // updated');
+  });
+
+  test('handles multiline content correctly', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(
+      filePath,
+      `class MyClass {
+  constructor() {
+    this.value = 1;
+    this.name = "test";
+    this.items = [];
+  }
+
+  method() {
+    return this.value;
+  }
+}`
+    );
+
+    await fastEdit.executor(
+      {
+        path: filePath,
+        prefix: 'constructor() {',
+        suffix: '}',
+        newText: `constructor() {
+    this.value = 42;
+  }`,
+      },
+      { rootDir: TEST_DIR }
+    );
+
+    const result = fs.readFileSync(filePath, 'utf-8');
+    expect(result).toContain('this.value = 42');
+    expect(result).not.toContain('this.name = "test"');
+    expect(result).toContain('method()'); // Other method unchanged
+  });
+});

package/src/runtime/stdlib/glob.test.ts

@@ -0,0 +1,106 @@
+// Tests for the glob tool
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { glob } from './tools';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const TEST_DIR = path.join(__dirname, '.test-workspace-glob');
+
+describe('glob tool', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  test('matches files with simple pattern', async () => {
+    fs.writeFileSync(path.join(TEST_DIR, 'file1.ts'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'file2.ts'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'file3.js'), '');
+
+    const result = (await glob.executor({ pattern: '*.ts' }, { rootDir: TEST_DIR })) as string[];
+
+    expect(result).toHaveLength(2);
+    expect(result).toContain('file1.ts');
+    expect(result).toContain('file2.ts');
+  });
+
+  test('matches files recursively with **', async () => {
+    fs.mkdirSync(path.join(TEST_DIR, 'src'), { recursive: true });
+    fs.mkdirSync(path.join(TEST_DIR, 'src', 'utils'), { recursive: true });
+    fs.writeFileSync(path.join(TEST_DIR, 'root.ts'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'src', 'index.ts'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'src', 'utils', 'helper.ts'), '');
+
+    const result = (await glob.executor({ pattern: '**/*.ts' }, { rootDir: TEST_DIR })) as string[];
+
+    expect(result).toHaveLength(3);
+    expect(result).toContain('root.ts');
+    expect(result.some((f) => f.includes('index.ts'))).toBe(true);
+    expect(result.some((f) => f.includes('helper.ts'))).toBe(true);
+  });
+
+  test('matches with custom cwd', async () => {
+    fs.mkdirSync(path.join(TEST_DIR, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(TEST_DIR, 'root.ts'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'src', 'index.ts'), '');
+
+    const result = (await glob.executor({ pattern: '*.ts', cwd: 'src' }, { rootDir: TEST_DIR })) as string[];
+
+    expect(result).toHaveLength(1);
+    expect(result).toContain('index.ts');
+  });
+
+  test('returns empty array when no matches', async () => {
+    fs.writeFileSync(path.join(TEST_DIR, 'file.js'), '');
+
+    const result = (await glob.executor({ pattern: '*.ts' }, { rootDir: TEST_DIR })) as string[];
+
+    expect(result).toEqual([]);
+  });
+
+  test('matches multiple extensions with braces', async () => {
+    fs.writeFileSync(path.join(TEST_DIR, 'file1.ts'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'file2.tsx'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'file3.js'), '');
+
+    const result = (await glob.executor(
+      { pattern: '*.{ts,tsx}' },
+      { rootDir: TEST_DIR }
+    )) as string[];
+
+    expect(result).toHaveLength(2);
+    expect(result).toContain('file1.ts');
+    expect(result).toContain('file2.tsx');
+  });
+
+  test('matches files starting with specific prefix', async () => {
+    fs.writeFileSync(path.join(TEST_DIR, 'test-one.ts'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'test-two.ts'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'other.ts'), '');
+
+    const result = (await glob.executor({ pattern: 'test-*.ts' }, { rootDir: TEST_DIR })) as string[];
+
+    expect(result).toHaveLength(2);
+    expect(result).toContain('test-one.ts');
+    expect(result).toContain('test-two.ts');
+  });
+
+  test('matches single character with ?', async () => {
+    fs.writeFileSync(path.join(TEST_DIR, 'file1.ts'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'file2.ts'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'file10.ts'), '');
+
+    const result = (await glob.executor({ pattern: 'file?.ts' }, { rootDir: TEST_DIR })) as string[];
+
+    expect(result).toHaveLength(2);
+    expect(result).toContain('file1.ts');
+    expect(result).toContain('file2.ts');
+    expect(result).not.toContain('file10.ts');
+  });
+});

package/src/runtime/stdlib/grep.test.ts

@@ -0,0 +1,144 @@
+// Tests for the grep tool
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { grep } from './tools';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const TEST_DIR = path.join(__dirname, '.test-workspace-grep');
+
+interface GrepMatch {
+  file: string;
+  line: number;
+  match: string;
+}
+
+describe('grep tool', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  test('finds matches in single file', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const foo = 1;\nconst bar = 2;\nconst foobar = 3;');
+
+    const result = (await grep.executor(
+      { pattern: 'foo', path: 'test.ts' },
+      { rootDir: TEST_DIR }
+    )) as GrepMatch[];
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({ file: 'test.ts', line: 1, match: 'foo' });
+    expect(result[1]).toEqual({ file: 'test.ts', line: 3, match: 'foo' });
+  });
+
+  test('searches directory recursively', async () => {
+    fs.mkdirSync(path.join(TEST_DIR, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(TEST_DIR, 'root.ts'), 'const target = 1;');
+    fs.writeFileSync(path.join(TEST_DIR, 'src', 'index.ts'), 'const target = 2;');
+
+    const result = (await grep.executor({ pattern: 'target', path: '.' }, { rootDir: TEST_DIR })) as GrepMatch[];
+
+    expect(result).toHaveLength(2);
+    expect(result.some((m) => m.file === 'root.ts')).toBe(true);
+    expect(result.some((m) => m.file.includes('index.ts'))).toBe(true);
+  });
+
+  test('supports regex patterns', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const foo123 = 1;\nconst bar = 2;\nconst foo456 = 3;');
+
+    const result = (await grep.executor(
+      { pattern: 'foo\\d+', path: 'test.ts' },
+      { rootDir: TEST_DIR }
+    )) as GrepMatch[];
+
+    expect(result).toHaveLength(2);
+    expect(result[0].match).toBe('foo123');
+    expect(result[1].match).toBe('foo456');
+  });
+
+  test('case insensitive search with ignoreCase', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const FOO = 1;\nconst foo = 2;\nconst Foo = 3;');
+
+    const result = (await grep.executor(
+      { pattern: 'foo', path: 'test.ts', ignoreCase: true },
+      { rootDir: TEST_DIR }
+    )) as GrepMatch[];
+
+    expect(result).toHaveLength(3);
+  });
+
+  test('case sensitive by default', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const FOO = 1;\nconst foo = 2;\nconst Foo = 3;');
+
+    const result = (await grep.executor(
+      { pattern: 'foo', path: 'test.ts' },
+      { rootDir: TEST_DIR }
+    )) as GrepMatch[];
+
+    expect(result).toHaveLength(1);
+    expect(result[0].line).toBe(2);
+  });
+
+  test('returns empty array when no matches', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const bar = 1;');
+
+    const result = (await grep.executor(
+      { pattern: 'foo', path: 'test.ts' },
+      { rootDir: TEST_DIR }
+    )) as GrepMatch[];
+
+    expect(result).toEqual([]);
+  });
+
+  test('finds multiple matches on same line', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'foo bar foo baz foo');
+
+    const result = (await grep.executor(
+      { pattern: 'foo', path: 'test.ts' },
+      { rootDir: TEST_DIR }
+    )) as GrepMatch[];
+
+    expect(result).toHaveLength(3);
+    expect(result.every((m) => m.line === 1)).toBe(true);
+  });
+
+  test('handles special regex characters when escaped', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'const x = a.b;\nconst y = a*b;');
+
+    // Search for literal "a.b" (escaped dot)
+    const result = (await grep.executor(
+      { pattern: 'a\\.b', path: 'test.ts' },
+      { rootDir: TEST_DIR }
+    )) as GrepMatch[];
+
+    expect(result).toHaveLength(1);
+    expect(result[0].match).toBe('a.b');
+  });
+
+  test('returns correct line numbers (1-based)', async () => {
+    const filePath = path.join(TEST_DIR, 'test.ts');
+    fs.writeFileSync(filePath, 'line1\nline2\ntarget\nline4\ntarget');
+
+    const result = (await grep.executor(
+      { pattern: 'target', path: 'test.ts' },
+      { rootDir: TEST_DIR }
+    )) as GrepMatch[];
+
+    expect(result).toHaveLength(2);
+    expect(result[0].line).toBe(3);
+    expect(result[1].line).toBe(5);
+  });
+});

package/src/runtime/stdlib/index.ts

@@ -0,0 +1,16 @@
+// Standard library functions for Vibe scripts
+// Import with: import { uuid } from "system"
+//
+// These are TypeScript functions that can be called directly from Vibe scripts.
+// For AI tools, use: import { allTools } from "system/tools"
+//
+// NOTE: print() and env() are auto-imported core functions.
+// They are available everywhere without import and CANNOT be imported from "system".
+
+/**
+ * Generate a UUID v4.
+ * @returns A new UUID string
+ */
+export function uuid(): string {
+  return crypto.randomUUID();
+}