@vibe-lang/runtime 0.2.5

package/src/runtime/test/while.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { createInitialState, runUntilPause } from '../index';
+
+describe('Runtime While Loop', () => {
+  // ============================================================================
+  // Basic while loop
+  // ============================================================================
+
+  test('while loop executes while condition is true', () => {
+    const ast = parse(`
+      let keepGoing = true
+      let executed = false
+      while keepGoing {
+        executed = true
+        keepGoing = false
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['executed'].value).toBe(true);
+    expect(frame.locals['keepGoing'].value).toBe(false);
+  });
+
+  test('while loop with false condition never executes', () => {
+    const ast = parse(`
+      let executed = false
+      while false {
+        executed = true
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['executed'].value).toBe(false);
+  });
+
+  test('while loop with true initial condition executes once then exits', () => {
+    const ast = parse(`
+      let counter = true
+      let loopRan = false
+      while counter {
+        loopRan = true
+        counter = false
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['loopRan'].value).toBe(true);
+    expect(frame.locals['counter'].value).toBe(false);
+  });
+
+  // ============================================================================
+  // Scoping
+  // ============================================================================
+
+  test('variables declared in while body are cleaned up each iteration', () => {
+    // This tests that body-scoped variables don't persist
+    const ast = parse(`
+      let flag = true
+      let outsideVar = false
+      while flag {
+        let insideVar = true
+        outsideVar = insideVar
+        flag = false
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['outsideVar'].value).toBe(true);
+    // insideVar should not exist in the frame after loop completes
+    expect(frame.locals['insideVar']).toBeUndefined();
+  });
+
+  test('while loop does not leak scope to outer context', () => {
+    const ast = parse(`
+      let preLoop = true
+      while false {
+        let loopVar = true
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['preLoop'].value).toBe(true);
+    expect(frame.locals['loopVar']).toBeUndefined();
+  });
+
+  // ============================================================================
+  // Nested while loops
+  // ============================================================================
+
+  test('nested while loops work correctly', () => {
+    const ast = parse(`
+      let outer = true
+      let inner = true
+      let outerRan = false
+      let innerRan = false
+      while outer {
+        outerRan = true
+        while inner {
+          innerRan = true
+          inner = false
+        }
+        outer = false
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['outerRan'].value).toBe(true);
+    expect(frame.locals['innerRan'].value).toBe(true);
+    expect(frame.locals['outer'].value).toBe(false);
+    expect(frame.locals['inner'].value).toBe(false);
+  });
+
+  // ============================================================================
+  // Error cases
+  // ============================================================================
+
+  test('while with non-boolean condition throws error', () => {
+    const ast = parse(`
+      while "not a boolean" {
+        let x = 1
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('error');
+    expect(state.error).toContain('boolean');
+  });
+
+  test('while with number condition throws error', () => {
+    const ast = parse(`
+      while 1 {
+        let x = 1
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('error');
+    expect(state.error).toContain('boolean');
+  });
+
+  test('while with string variable condition throws error', () => {
+    const ast = parse(`
+      const x = "test"
+      while x {
+        let y = 1
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('error');
+    expect(state.error).toContain('boolean');
+  });
+
+  test('while with number variable condition throws error', () => {
+    const ast = parse(`
+      let count = 5
+      while count {
+        count = 0
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('error');
+    expect(state.error).toContain('boolean');
+  });
+
+  // ============================================================================
+  // Integration with other constructs
+  // ============================================================================
+
+  test('while loop with if statement inside', () => {
+    const ast = parse(`
+      let flag = true
+      let tookBranch = false
+      while flag {
+        if true {
+          tookBranch = true
+        }
+        flag = false
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['tookBranch'].value).toBe(true);
+  });
+
+  test('while loop inside function', () => {
+    const ast = parse(`
+      function loopOnce(): boolean {
+        let done = false
+        while true {
+          done = true
+          return done
+        }
+        return false
+      }
+      let result = loopOnce()
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['result'].value).toBe(true);
+  });
+});

package/src/runtime/tools/builtin.ts

@@ -0,0 +1,30 @@
+import type { RegisteredTool } from './types';
+import { fileTools } from './file-tools';
+import { searchTools } from './search-tools';
+import { directoryTools } from './directory-tools';
+import { utilityTools } from './utility-tools';
+import { systemTools } from './system-tools';
+
+/**
+ * Standard tools available in the Vibe runtime.
+ * Combines all tool categories into a single array.
+ *
+ * Categories:
+ * - File operations: readFile, writeFile, appendFile, fileExists, listDir, edit
+ * - File search: glob, grep
+ * - Directory operations: mkdir, dirExists
+ * - Utilities: env, sleep, now, jsonParse, jsonStringify, print, random, uuid
+ * - System: bash, runCode
+ *
+ * Total: 20 tools
+ */
+export const allTools: RegisteredTool[] = [
+  ...fileTools,
+  ...searchTools,
+  ...directoryTools,
+  ...utilityTools,
+  ...systemTools,
+];
+
+/** @deprecated Use allTools instead */
+export const builtinTools = allTools;

package/src/runtime/tools/directory-tools.ts

@@ -0,0 +1,70 @@
+import type { RegisteredTool, ToolContext } from './types';
+import { validatePathInSandbox } from './security';
+
+/**
+ * Directory operation tools: mkdir, dirExists
+ */
+export const directoryTools = [
+  {
+    name: 'mkdir',
+    kind: 'builtin',
+    schema: {
+      name: 'mkdir',
+      description: 'Create a directory.',
+      parameters: [
+        {
+          name: 'path',
+          type: { type: 'string' },
+          description: 'The directory path to create',
+          required: true,
+        },
+        {
+          name: 'recursive',
+          type: { type: 'boolean' },
+          description: 'Create parent directories as needed (default: false)',
+          required: false,
+        },
+      ],
+      returns: { type: 'boolean' },
+    },
+    executor: async (args: Record<string, unknown>, context?: ToolContext) => {
+      const inputPath = args.path as string;
+      const safePath = context ? validatePathInSandbox(inputPath, context.rootDir) : inputPath;
+      const recursive = args.recursive as boolean | undefined;
+
+      const fs = await import('fs/promises');
+      await fs.mkdir(safePath, { recursive: recursive ?? false });
+      return true;
+    },
+  },
+
+  {
+    name: 'dirExists',
+    kind: 'builtin',
+    schema: {
+      name: 'dirExists',
+      description: 'Check if a directory exists.',
+      parameters: [
+        {
+          name: 'path',
+          type: { type: 'string' },
+          description: 'The directory path to check',
+          required: true,
+        },
+      ],
+      returns: { type: 'boolean' },
+    },
+    executor: async (args: Record<string, unknown>, context?: ToolContext) => {
+      const inputPath = args.path as string;
+      const safePath = context ? validatePathInSandbox(inputPath, context.rootDir) : inputPath;
+
+      const fs = await import('fs/promises');
+      try {
+        const stats = await fs.stat(safePath);
+        return stats.isDirectory();
+      } catch {
+        return false;
+      }
+    },
+  },
+] satisfies RegisteredTool[];

package/src/runtime/tools/file-tools.ts

@@ -0,0 +1,228 @@
+import type { RegisteredTool, ToolContext } from './types';
+import { validatePathInSandbox } from './security';
+
+/**
+ * File operation tools: read, write, append, exists, list, edit
+ */
+export const fileTools = [
+  {
+    name: 'readFile',
+    kind: 'builtin',
+    schema: {
+      name: 'readFile',
+      description: 'Read the contents of a file as text. Optionally read a range of lines.',
+      parameters: [
+        {
+          name: 'path',
+          type: { type: 'string' },
+          description: 'The file path to read',
+          required: true,
+        },
+        {
+          name: 'startLine',
+          type: { type: 'number' },
+          description: 'First line to read (1-based, inclusive). If omitted, starts from beginning.',
+          required: false,
+        },
+        {
+          name: 'endLine',
+          type: { type: 'number' },
+          description: 'Last line to read (1-based, inclusive). If omitted, reads to end of file.',
+          required: false,
+        },
+      ],
+      returns: { type: 'string' },
+    },
+    executor: async (args: Record<string, unknown>, context?: ToolContext) => {
+      const inputPath = args.path as string;
+      const safePath = context ? validatePathInSandbox(inputPath, context.rootDir) : inputPath;
+      const startLine = args.startLine as number | undefined;
+      const endLine = args.endLine as number | undefined;
+
+      const file = Bun.file(safePath);
+      const content = await file.text();
+
+      // If no line range specified, return entire file
+      if (startLine === undefined && endLine === undefined) {
+        return content;
+      }
+
+      // Split into lines and extract the requested range
+      const lines = content.split('\n');
+      const start = startLine !== undefined ? Math.max(1, startLine) - 1 : 0;  // Convert to 0-based
+      const end = endLine !== undefined ? Math.min(lines.length, endLine) : lines.length;
+
+      return lines.slice(start, end).join('\n');
+    },
+  },
+
+  {
+    name: 'writeFile',
+    kind: 'builtin',
+    schema: {
+      name: 'writeFile',
+      description: 'Write content to a file.',
+      parameters: [
+        {
+          name: 'path',
+          type: { type: 'string' },
+          description: 'The file path to write to',
+          required: true,
+        },
+        {
+          name: 'content',
+          type: { type: 'string' },
+          description: 'The content to write',
+          required: true,
+        },
+      ],
+      returns: { type: 'boolean' },
+    },
+    executor: async (args: Record<string, unknown>, context?: ToolContext) => {
+      const inputPath = args.path as string;
+      const safePath = context ? validatePathInSandbox(inputPath, context.rootDir) : inputPath;
+      const content = args.content as string;
+      await Bun.write(safePath, content);
+      return true;
+    },
+  },
+
+  {
+    name: 'appendFile',
+    kind: 'builtin',
+    schema: {
+      name: 'appendFile',
+      description: 'Append content to a file.',
+      parameters: [
+        {
+          name: 'path',
+          type: { type: 'string' },
+          description: 'The file path to append to',
+          required: true,
+        },
+        {
+          name: 'content',
+          type: { type: 'string' },
+          description: 'The content to append',
+          required: true,
+        },
+      ],
+      returns: { type: 'boolean' },
+    },
+    executor: async (args: Record<string, unknown>, context?: ToolContext) => {
+      const inputPath = args.path as string;
+      const safePath = context ? validatePathInSandbox(inputPath, context.rootDir) : inputPath;
+      const content = args.content as string;
+      const file = Bun.file(safePath);
+      const existing = (await file.exists()) ? await file.text() : '';
+      await Bun.write(safePath, existing + content);
+      return true;
+    },
+  },
+
+  {
+    name: 'fileExists',
+    kind: 'builtin',
+    schema: {
+      name: 'fileExists',
+      description: 'Check if a file exists.',
+      parameters: [
+        {
+          name: 'path',
+          type: { type: 'string' },
+          description: 'The file path to check',
+          required: true,
+        },
+      ],
+      returns: { type: 'boolean' },
+    },
+    executor: async (args: Record<string, unknown>, context?: ToolContext) => {
+      const inputPath = args.path as string;
+      const safePath = context ? validatePathInSandbox(inputPath, context.rootDir) : inputPath;
+      const file = Bun.file(safePath);
+      return await file.exists();
+    },
+  },
+
+  {
+    name: 'listDir',
+    kind: 'builtin',
+    schema: {
+      name: 'listDir',
+      description: 'List files in a directory.',
+      parameters: [
+        {
+          name: 'path',
+          type: { type: 'string' },
+          description: 'The directory path to list',
+          required: true,
+        },
+      ],
+      returns: { type: 'array', items: { type: 'string' } },
+    },
+    executor: async (args: Record<string, unknown>, context?: ToolContext) => {
+      const inputPath = args.path as string;
+      const safePath = context ? validatePathInSandbox(inputPath, context.rootDir) : inputPath;
+      const fs = await import('fs/promises');
+      return await fs.readdir(safePath);
+    },
+  },
+
+  {
+    name: 'edit',
+    kind: 'builtin',
+    schema: {
+      name: 'edit',
+      description:
+        'Find and replace text in a file. The oldText must match exactly once in the file.',
+      parameters: [
+        {
+          name: 'path',
+          type: { type: 'string' },
+          description: 'The file path to edit',
+          required: true,
+        },
+        {
+          name: 'oldText',
+          type: { type: 'string' },
+          description: 'The text to find (must match exactly once)',
+          required: true,
+        },
+        {
+          name: 'newText',
+          type: { type: 'string' },
+          description: 'The text to replace with',
+          required: true,
+        },
+      ],
+      returns: { type: 'boolean' },
+    },
+    executor: async (args: Record<string, unknown>, context?: ToolContext) => {
+      const inputPath = args.path as string;
+      const safePath = context ? validatePathInSandbox(inputPath, context.rootDir) : inputPath;
+      const oldText = args.oldText as string;
+      const newText = args.newText as string;
+
+      const file = Bun.file(safePath);
+      const content = await file.text();
+
+      // Count occurrences of oldText
+      const matches = content.split(oldText).length - 1;
+
+      if (matches === 0) {
+        throw new Error(`edit failed: oldText not found in file`);
+      }
+
+      if (matches > 1) {
+        throw new Error(
+          `edit failed: oldText matches ${matches} times, must match exactly once. Provide more context to make the match unique.`
+        );
+      }
+
+      // Exactly one match - safe to replace
+      const newContent = content.replace(oldText, newText);
+      await Bun.write(safePath, newContent);
+      return true;
+    },
+  },
+] satisfies RegisteredTool[];

package/src/runtime/tools/index.ts

@@ -0,0 +1,5 @@
+// Tool system types and utilities
+export * from './types';
+export { extractTypeSchema, vibeTypeToJsonSchema, clearSchemaCache, createTypeExtractor } from './ts-schema';
+export type { TypeExtractor } from './ts-schema';
+export { validatePathInSandbox } from './security';

package/src/runtime/tools/registry.ts

@@ -0,0 +1,48 @@
+import type { RegisteredTool, ToolRegistry, ToolSchema } from './types';
+import { allTools } from './builtin';
+
+/**
+ * Create a new tool registry.
+ * Tools are stored in a Map for O(1) lookup.
+ */
+export function createToolRegistry(): ToolRegistry {
+  const tools = new Map<string, RegisteredTool>();
+
+  return {
+    register(tool: RegisteredTool): void {
+      // Allow overwriting existing tools (user tools can shadow builtins)
+      tools.set(tool.name, tool);
+    },
+
+    registerAll(toolsToAdd: RegisteredTool[]): void {
+      for (const tool of toolsToAdd) {
+        tools.set(tool.name, tool);
+      }
+    },
+
+    get(name: string): RegisteredTool | undefined {
+      return tools.get(name);
+    },
+
+    has(name: string): boolean {
+      return tools.has(name);
+    },
+
+    list(): RegisteredTool[] {
+      return Array.from(tools.values());
+    },
+
+    getSchemas(): ToolSchema[] {
+      return Array.from(tools.values()).map((t) => t.schema);
+    },
+  };
+}
+
+/**
+ * Create a tool registry pre-populated with standard tools.
+ */
+export function createToolRegistryWithBuiltins(): ToolRegistry {
+  const registry = createToolRegistry();
+  registry.registerAll(allTools);
+  return registry;
+}