chrometools-mcp 1.9.1 → 2.3.2

package/server/tool-schemas.js

@@ -0,0 +1,295 @@
+/**
+ * server/tool-schemas.js
+ *
+ * Zod schemas for all MCP tools
+ */
+
+import { z } from 'zod';
+
+// Basic tools
+export const PingSchema = z.object({
+  message: z.string().optional().describe("Optional message to send"),
+});
+
+export const OpenBrowserSchema = z.object({
+  url: z.string().describe("URL to open in the browser"),
+});
+
+export const ClickSchema = z.object({
+  selector: z.string().describe("CSS selector for element to click"),
+  waitAfter: z.number().optional().describe("Milliseconds to wait after click (default: 1500)"),
+  screenshot: z.boolean().optional().describe("Capture screenshot after click (default: false for performance)"),
+  timeout: z.number().optional().describe("Maximum time to wait for operation in ms (default: 30000)"),
+});
+
+export const TypeSchema = z.object({
+  selector: z.string().describe("CSS selector for input element"),
+  text: z.string().describe("Text to type"),
+  delay: z.number().optional().describe("Delay between keystrokes in ms (default: 0)"),
+  clearFirst: z.boolean().optional().describe("Clear field before typing (default: true)"),
+});
+
+export const GetElementSchema = z.object({
+  selector: z.string().optional().describe("CSS selector (optional, defaults to body)"),
+});
+
+export const HoverSchema = z.object({
+  selector: z.string().describe("CSS selector for element to hover"),
+});
+
+// CSS tools
+export const GetComputedCssSchema = z.object({
+  selector: z.string().optional().describe("CSS selector (optional, defaults to body)"),
+  category: z.enum(['all', 'layout', 'typography', 'colors', 'visual']).optional().describe("Filter by CSS category: 'layout' (sizing, positioning), 'typography' (fonts, text), 'colors' (color schemes), 'visual' (effects, transforms), 'all' (default)"),
+  properties: z.array(z.string()).optional().describe("Specific CSS properties to return (e.g., ['color', 'font-size']). Overrides category filter."),
+  includeDefaults: z.boolean().optional().describe("Include properties with default values (default: false)"),
+});
+
+export const GetBoxModelSchema = z.object({
+  selector: z.string().describe("CSS selector for element"),
+});
+
+export const SetStylesSchema = z.object({
+  selector: z.string().describe("CSS selector for element to modify"),
+  styles: z.array(z.object({
+    name: z.string().describe("CSS property name (e.g., 'color')"),
+    value: z.string().describe("CSS property value (e.g., 'red')")
+  })).describe("Array of CSS property name-value pairs"),
+});
+
+// Screenshot tools
+export const ScreenshotSchema = z.object({
+  selector: z.string().describe("CSS selector for element to screenshot"),
+  padding: z.number().optional().describe("Padding around element in pixels (default: 0)"),
+  maxWidth: z.number().nullable().optional().describe("Maximum width in pixels, auto-scales if larger (default: 1024, set to null for original size)"),
+  maxHeight: z.number().nullable().optional().describe("Maximum height in pixels, auto-scales if larger (default: 8000 for API limit, set to null for original size)"),
+  quality: z.number().min(1).max(100).optional().describe("JPEG quality 1-100 (default: 80, only applies to JPEG format)"),
+  format: z.enum(['png', 'jpeg', 'auto']).optional().describe("Image format: 'png', 'jpeg', or 'auto' (default: 'auto' - chooses based on size)"),
+});
+
+export const SaveScreenshotSchema = z.object({
+  selector: z.string().describe("CSS selector for element to screenshot"),
+  filePath: z.string().describe("Absolute path where to save file"),
+  padding: z.number().optional().describe("Padding around element in pixels (default: 0)"),
+  maxWidth: z.number().nullable().optional().describe("Maximum width in pixels, auto-scales if larger (default: 1024, set to null for original size)"),
+  maxHeight: z.number().nullable().optional().describe("Maximum height in pixels, auto-scales if larger (default: 8000 for API limit, set to null for original size)"),
+  quality: z.number().min(1).max(100).optional().describe("JPEG quality 1-100 (default: 80, only applies to JPEG format)"),
+  format: z.enum(['png', 'jpeg', 'auto']).optional().describe("Image format: 'png', 'jpeg', or 'auto' (default: 'auto' - chooses based on size)"),
+});
+
+// Navigation tools
+export const ScrollToSchema = z.object({
+  selector: z.string().describe("CSS selector for element to scroll to"),
+  behavior: z.enum(['auto', 'smooth']).optional().describe("Scroll behavior (default: auto)"),
+});
+
+export const WaitForElementSchema = z.object({
+  selector: z.string().describe("CSS selector to wait for"),
+  timeout: z.number().optional().describe("Maximum time to wait in milliseconds (default: 5000)"),
+  visible: z.boolean().optional().describe("Wait for element to be visible (default: true)"),
+});
+
+export const NavigateToSchema = z.object({
+  url: z.string().describe("URL to navigate to"),
+  waitUntil: z.enum(['load', 'domcontentloaded', 'networkidle0', 'networkidle2'])
+    .optional()
+    .describe("Wait until event (default: networkidle2)"),
+});
+
+export const SetViewportSchema = z.object({
+  width: z.number().min(320).max(4000).describe("Viewport width in pixels (320-4000)"),
+  height: z.number().min(200).max(3000).describe("Viewport height in pixels (200-3000)"),
+  deviceScaleFactor: z.number().min(0.5).max(3).optional().describe("Device pixel ratio (0.5-3, default: 1)"),
+});
+
+export const GetViewportSchema = z.object({});
+
+// Script execution
+export const ExecuteScriptSchema = z.object({
+  script: z.string().describe("JavaScript code to execute in page context"),
+  waitAfter: z.number().optional().describe("Milliseconds to wait after execution (default: 500)"),
+  screenshot: z.boolean().optional().describe("Capture screenshot after execution (default: false for performance)"),
+  timeout: z.number().optional().describe("Maximum time to wait for operation in ms (default: 30000)"),
+});
+
+// Network monitoring tools
+export const GetConsoleLogsSchema = z.object({
+  types: z.array(z.enum(['log', 'warn', 'error', 'info', 'debug', 'verbose', 'warning']))
+    .optional()
+    .describe("Filter by log types (default: all)"),
+  clear: z.boolean().optional().describe("Clear logs after reading (default: false)"),
+});
+
+export const ListNetworkRequestsSchema = z.object({
+  types: z.array(z.enum(['Document', 'Stylesheet', 'Image', 'Media', 'Font', 'Script', 'XHR', 'Fetch', 'WebSocket', 'Other']))
+    .optional()
+    .default(['Fetch', 'XHR'])
+    .describe("Filter by request types (default: Fetch, XHR)"),
+  status: z.enum(['pending', 'completed', 'failed', 'all'])
+    .optional()
+    .describe("Filter by status (default: all)"),
+  limit: z.number().min(1).max(500).optional().default(50).describe("Maximum number of requests to return (default: 50)"),
+  offset: z.number().min(0).optional().default(0).describe("Number of requests to skip before returning results (default: 0)"),
+  clear: z.boolean().optional().describe("Clear requests after reading (default: false)"),
+});
+
+export const GetNetworkRequestSchema = z.object({
+  requestId: z.string().describe("Request ID to get details for"),
+});
+
+export const FilterNetworkRequestsSchema = z.object({
+  urlPattern: z.string().describe("URL pattern to filter by (regex or partial match)"),
+  types: z.array(z.enum(['Document', 'Stylesheet', 'Image', 'Media', 'Font', 'Script', 'XHR', 'Fetch', 'WebSocket', 'Other']))
+    .optional()
+    .default(['Fetch', 'XHR'])
+    .describe("Filter by request types (default: Fetch, XHR)"),
+  clear: z.boolean().optional().describe("Clear requests after reading (default: false)"),
+});
+
+// Figma tools
+export const GetFigmaFrameSchema = z.object({
+  figmaToken: z.string().optional().describe("Figma API token (optional if FIGMA_TOKEN env var is set)"),
+  fileKey: z.string().describe("Figma file key (from URL: figma.com/file/FILE_KEY/...)"),
+  nodeId: z.string().describe("Figma node ID (frame/component ID)"),
+  scale: z.number().min(0.1).max(4).optional().describe("Export scale (0.1-4, default: 2)"),
+  format: z.enum(['png', 'jpg', 'svg']).optional().describe("Export format (default: png)")
+});
+
+export const CompareFigmaToElementSchema = z.object({
+  figmaToken: z.string().optional().describe("Figma API token (optional if FIGMA_TOKEN env var is set)"),
+  fileKey: z.string().describe("Figma file key"),
+  nodeId: z.string().describe("Figma frame/component ID"),
+  selector: z.string().describe("CSS selector for page element"),
+  threshold: z.number().min(0).max(1).optional().describe("Difference threshold (0-1, default: 0.05)"),
+  figmaScale: z.number().min(0.1).max(4).optional().describe("Figma export scale (default: 2)")
+});
+
+export const GetFigmaSpecsSchema = z.object({
+  figmaToken: z.string().optional().describe("Figma API token (optional if FIGMA_TOKEN env var is set)"),
+  fileKey: z.string().describe("Figma file key"),
+  nodeId: z.string().describe("Figma frame/component ID")
+});
+
+export const ParseFigmaUrlSchema = z.object({
+  url: z.string().describe("Full Figma URL or fileKey")
+});
+
+export const ListFigmaPagesSchema = z.object({
+  figmaToken: z.string().optional().describe("Figma API token (optional if FIGMA_TOKEN env var is set)"),
+  fileKey: z.string().describe("Figma file key or full Figma URL")
+});
+
+export const SearchFigmaFramesSchema = z.object({
+  figmaToken: z.string().optional().describe("Figma API token (optional if FIGMA_TOKEN env var is set)"),
+  fileKey: z.string().describe("Figma file key or full Figma URL"),
+  searchQuery: z.string().describe("Search query")
+});
+
+export const GetFigmaComponentsSchema = z.object({
+  figmaToken: z.string().optional().describe("Figma API token (optional if FIGMA_TOKEN env var is set)"),
+  fileKey: z.string().describe("Figma file key or full Figma URL")
+});
+
+export const GetFigmaStylesSchema = z.object({
+  figmaToken: z.string().optional().describe("Figma API token (optional if FIGMA_TOKEN env var is set)"),
+  fileKey: z.string().describe("Figma file key or full Figma URL")
+});
+
+export const GetFigmaColorPaletteSchema = z.object({
+  figmaToken: z.string().optional().describe("Figma API token (optional if FIGMA_TOKEN env var is set)"),
+  fileKey: z.string().describe("Figma file key or full Figma URL")
+});
+
+// Page analysis tools
+export const SmartFindElementSchema = z.object({
+  description: z.string().describe("Natural language description of element to find (e.g., 'login button', 'email field')"),
+  maxResults: z.number().min(1).max(20).optional().describe("Maximum number of candidates to return (default: 5)"),
+  action: z.object({
+    type: z.enum(['click', 'type', 'scrollTo', 'screenshot', 'hover', 'setStyles']).describe("Action to perform on the best match"),
+    text: z.string().optional().describe("Text to type (required for 'type' action)"),
+    styles: z.array(z.object({
+      name: z.string(),
+      value: z.string()
+    })).optional().describe("Styles to apply (required for 'setStyles' action)"),
+    screenshot: z.boolean().optional().describe("Capture screenshot after action (default: false)"),
+    waitAfter: z.number().optional().describe("Wait time in ms after action"),
+  }).optional().describe("Optional action to perform on the best matching element"),
+});
+
+export const AnalyzePageSchema = z.object({
+  refresh: z.boolean().optional().describe("Force refresh of cached analysis (default: false)"),
+});
+
+export const GetAllInteractiveElementsSchema = z.object({
+  includeHidden: z.boolean().optional().describe("Include hidden elements (default: false)"),
+});
+
+export const FindElementsByTextSchema = z.object({
+  text: z.string().describe("Text to search for in elements"),
+  exact: z.boolean().optional().describe("Exact match only (default: false)"),
+  caseSensitive: z.boolean().optional().describe("Case sensitive search (default: false)"),
+  action: z.object({
+    type: z.enum(['click', 'type', 'scrollTo', 'screenshot', 'hover', 'setStyles']).describe("Action to perform on the first match"),
+    text: z.string().optional().describe("Text to type (required for 'type' action)"),
+    styles: z.array(z.object({
+      name: z.string(),
+      value: z.string()
+    })).optional().describe("Styles to apply (required for 'setStyles' action)"),
+    screenshot: z.boolean().optional().describe("Capture screenshot after action (default: false)"),
+    waitAfter: z.number().optional().describe("Wait time in ms after action"),
+  }).optional().describe("Optional action to perform on the first matching element"),
+});
+
+// Recorder tools (schemas created from inline definitions)
+export const EnableRecorderSchema = z.object({
+  directory: z.string().optional().describe("Directory to save scenarios (optional, defaults to auto-detected project root)")
+});
+
+export const ExecuteScenarioSchema = z.object({
+  name: z.string().describe("Scenario name"),
+  projectId: z.string().optional().describe("Optional: Project ID (domain) to disambiguate scenarios with same name"),
+  parameters: z.record(z.any()).optional().describe("Execution parameters"),
+  executeDependencies: z.boolean().optional().describe("Execute dependencies (default: true)")
+});
+
+export const ListScenariosSchema = z.object({
+  directory: z.string().optional().describe("Directory where scenarios are stored (optional)")
+});
+
+export const SearchScenariosSchema = z.object({
+  text: z.string().optional().describe("Search text"),
+  tags: z.array(z.string()).optional().describe("Filter tags"),
+  directory: z.string().optional().describe("Directory where scenarios are stored (optional)")
+});
+
+export const GetScenarioInfoSchema = z.object({
+  name: z.string().describe("Scenario name"),
+  includeSecrets: z.boolean().optional().describe("Include secrets (default: false)"),
+  directory: z.string().optional().describe("Directory where scenarios are stored (optional)")
+});
+
+export const DeleteScenarioSchema = z.object({
+  name: z.string().describe("Scenario name"),
+  directory: z.string().optional().describe("Directory where scenarios are stored (optional)")
+});
+
+export const ExportScenarioAsCodeSchema = z.object({
+  scenarioName: z.string().describe("Name of scenario to export"),
+  language: z.enum(['playwright-typescript', 'playwright-python', 'selenium-python', 'selenium-java']).describe("Target test framework and language"),
+  cleanSelectors: z.boolean().optional().describe("Remove unstable CSS classes (default: true)"),
+  includeComments: z.boolean().optional().describe("Include descriptive comments (default: true)"),
+  generatePageObject: z.boolean().optional().describe("Also generate Page Object class for the page (default: false)"),
+  pageObjectClassName: z.string().optional().describe("Page Object class name (optional, auto-generated if not provided)"),
+  directory: z.string().optional().describe("Directory where scenarios are stored (optional)"),
+  appendToFile: z.string().optional().describe("Path to existing test file to append to (enables append mode)"),
+  testName: z.string().optional().describe("Override test name (default: from scenario name)"),
+  insertPosition: z.enum(['end', 'before', 'after']).optional().describe("Where to insert test: 'end' (default), 'before', or 'after' a reference test"),
+  referenceTestName: z.string().optional().describe("Reference test name for 'before'/'after' insertion")
+});
+
+export const GeneratePageObjectSchema = z.object({
+  className: z.string().optional().describe("Page Object class name (optional, auto-generated from page title/URL if not provided)"),
+  framework: z.enum(['playwright-typescript', 'playwright-python', 'selenium-python', 'selenium-java']).optional().describe("Target test framework (default: playwright-typescript)"),
+  includeComments: z.boolean().optional().describe("Include descriptive comments in generated code (default: true)"),
+  groupElements: z.boolean().optional().describe("Group elements by page sections (default: true)")
+});

package/utils/code-generators/code-generator-base.js

@@ -234,4 +234,65 @@ export class CodeGeneratorBase {
   generateUrlAssertion(expectedUrl) {
     throw new Error('generateUrlAssertion() must be implemented by subclass');
   }
+
+  /**
+   * Generate only test function/method (without imports)
+   * Used for appending tests to existing files
+   * @param {Object} scenario - Scenario object
+   * @param {Object} options - Generation options
+   * @returns {string} - Generated test code (no imports)
+   */
+  generateTestOnly(scenario, options = {}) {
+    this.options = { ...this.options, ...options };
+
+    const testName = options.testName || scenario.metadata?.name || 'test';
+    const description = scenario.metadata?.description || '';
+    const entryUrl = scenario.metadata?.entryUrl || '';
+    const exitUrl = scenario.metadata?.exitUrl || '';
+
+    const lines = [];
+
+    // Generate test function/method header
+    lines.push(...this.generateTestHeader(testName, description));
+    lines.push('');
+
+    // Generate navigation to entry URL
+    if (entryUrl) {
+      lines.push(...this.generateNavigate(entryUrl));
+    }
+
+    // Generate actions
+    for (const action of scenario.chain) {
+      const actionCode = this.generateAction(action);
+      if (actionCode && actionCode.length > 0) {
+        lines.push(...actionCode);
+      }
+    }
+
+    // Generate exit URL validation
+    if (exitUrl) {
+      lines.push('');
+      if (this.options.includeComments) {
+        lines.push(this.indent(this.generateComment('Validate final URL'), 1));
+      }
+      lines.push(...this.generateUrlAssertion(exitUrl));
+    }
+
+    // Generate test footer
+    lines.push(...this.generateTestFooter());
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Append test to existing file content
+   * Must be implemented by subclass for language-specific file parsing
+   * @param {string} existingContent - Current file content
+   * @param {string} newTestCode - New test code to insert
+   * @param {Object} options - Insertion options {insertPosition, referenceTestName}
+   * @returns {string} - Updated file content
+   */
+  appendTest(existingContent, newTestCode, options = {}) {
+    throw new Error('appendTest() must be implemented by subclass');
+  }
 }

package/utils/code-generators/file-appender.js

@@ -0,0 +1,202 @@
+/**
+ * utils/code-generators/file-appender.js
+ *
+ * Utilities for appending tests to existing test files
+ */
+
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
+import { extname } from 'path';
+
+export class FileAppender {
+  /**
+   * Expected file extensions for each language
+   */
+  static EXTENSIONS = {
+    'playwright-typescript': ['.ts', '.spec.ts', '.test.ts'],
+    'playwright-python': ['.py'],
+    'selenium-python': ['.py'],
+    'selenium-java': ['.java']
+  };
+
+  /**
+   * Read file with error handling
+   * @param {string} filePath - Path to file
+   * @returns {string} - File content
+   */
+  static readFile(filePath) {
+    if (!existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    try {
+      return readFileSync(filePath, 'utf-8');
+    } catch (error) {
+      throw new Error(`Failed to read file ${filePath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Write file with automatic backup
+   * @param {string} filePath - Path to file
+   * @param {string} content - Content to write
+   * @param {boolean} backup - Create backup before writing
+   */
+  static writeFile(filePath, content, backup = true) {
+    const backupPath = filePath + '.backup';
+    let originalContent = null;
+
+    try {
+      // Create backup if file exists and backup is requested
+      if (backup && existsSync(filePath)) {
+        originalContent = readFileSync(filePath, 'utf-8');
+        writeFileSync(backupPath, originalContent, 'utf-8');
+      }
+
+      // Write new content
+      writeFileSync(filePath, content, 'utf-8');
+
+      // Clean up backup on success
+      if (backup && existsSync(backupPath)) {
+        unlinkSync(backupPath);
+      }
+    } catch (error) {
+      // Restore from backup on failure
+      if (backup && originalContent !== null) {
+        try {
+          writeFileSync(filePath, originalContent, 'utf-8');
+        } catch (restoreError) {
+          throw new Error(`Failed to write file and restore backup: ${error.message}, ${restoreError.message}`);
+        }
+      }
+      throw new Error(`Failed to write file ${filePath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate file extension matches language
+   * @param {string} filePath - Path to file
+   * @param {string} language - Target language
+   * @throws {Error} If extension doesn't match
+   */
+  static validateFile(filePath, language) {
+    const ext = extname(filePath);
+    const expectedExts = this.EXTENSIONS[language];
+
+    if (!expectedExts) {
+      throw new Error(`Unknown language: ${language}`);
+    }
+
+    const isValid = expectedExts.some(e => filePath.endsWith(e));
+    if (!isValid) {
+      throw new Error(
+        `File extension doesn't match language: expected ${expectedExts.join(' or ')} for ${language}, got ${ext}`
+      );
+    }
+  }
+
+  /**
+   * Create backup of file
+   * @param {string} filePath - Path to file
+   * @returns {string} - Backup file path
+   */
+  static createBackup(filePath) {
+    const backupPath = filePath + '.backup';
+    if (existsSync(filePath)) {
+      const content = readFileSync(filePath, 'utf-8');
+      writeFileSync(backupPath, content, 'utf-8');
+    }
+    return backupPath;
+  }
+
+  /**
+   * Restore file from backup
+   * @param {string} filePath - Original file path
+   */
+  static restoreBackup(filePath) {
+    const backupPath = filePath + '.backup';
+    if (existsSync(backupPath)) {
+      const content = readFileSync(backupPath, 'utf-8');
+      writeFileSync(filePath, content, 'utf-8');
+      unlinkSync(backupPath);
+    }
+  }
+
+  /**
+   * Detect test framework from file content
+   * @param {string} content - File content
+   * @returns {string|null} - Detected framework or null
+   */
+  static detectFramework(content) {
+    // Playwright TypeScript patterns
+    if (content.includes("from '@playwright/test'") ||
+        content.includes('import { test, expect } from')) {
+      return 'playwright-typescript';
+    }
+
+    // Playwright Python patterns
+    if (content.includes('from playwright.sync_api import') ||
+        content.includes('from playwright.async_api import')) {
+      return 'playwright-python';
+    }
+
+    // Selenium Python patterns
+    if (content.includes('from selenium') ||
+        content.includes('import selenium')) {
+      return 'selenium-python';
+    }
+
+    // Selenium Java patterns
+    if (content.includes('import org.openqa.selenium') ||
+        content.includes('import org.junit')) {
+      return 'selenium-java';
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if file has unmatched braces (for TS/Java)
+   * @param {string} content - File content
+   * @returns {boolean} - True if unmatched
+   */
+  static hasUnmatchedBraces(content) {
+    let count = 0;
+    for (const char of content) {
+      if (char === '{') count++;
+      if (char === '}') count--;
+    }
+    return count !== 0;
+  }
+
+  /**
+   * Check if file is empty or contains only whitespace
+   * @param {string} content - File content
+   * @returns {boolean}
+   */
+  static isEmpty(content) {
+    return content.trim() === '';
+  }
+
+  /**
+   * Check if content has any test functions/methods
+   * @param {string} content - File content
+   * @param {string} language - Language to check for
+   * @returns {boolean}
+   */
+  static hasTests(content, language) {
+    switch (language) {
+      case 'playwright-typescript':
+        return /test\(['"`]/.test(content);
+
+      case 'playwright-python':
+      case 'selenium-python':
+        return /def test_\w+\s*\(/.test(content);
+
+      case 'selenium-java':
+        return /@Test/.test(content);
+
+      default:
+        return false;
+    }
+  }
+}

package/utils/code-generators/playwright-python.js

@@ -250,4 +250,88 @@ export class PlaywrightPythonGenerator extends CodeGeneratorBase {
 
     return lines;
   }
+
+  /**
+   * Append test to existing Python file
+   */
+  appendTest(existingContent, newTestCode, options = {}) {
+    const lines = existingContent.split('\n');
+    const insertPosition = options.insertPosition || 'end';
+    const referenceTestName = options.referenceTestName;
+
+    let insertIndex;
+
+    if (insertPosition === 'end') {
+      // Insert at end of file
+      insertIndex = lines.length;
+    } else if (insertPosition === 'before' || insertPosition === 'after') {
+      if (!referenceTestName) {
+        throw new Error(`referenceTestName is required for insertPosition '${insertPosition}'`);
+      }
+
+      const pythonTestName = this.pythonTestName(referenceTestName);
+      insertIndex = this.findPythonTestByName(lines, pythonTestName);
+
+      if (insertIndex === -1) {
+        throw new Error(`Reference test '${referenceTestName}' not found in file`);
+      }
+
+      if (insertPosition === 'after') {
+        insertIndex = this.findPythonTestEnd(lines, insertIndex);
+      }
+    }
+
+    // Insert new test with proper spacing (2 blank lines before test - PEP 8)
+    lines.splice(insertIndex, 0, '', '', newTestCode);
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Convert test name to Python convention
+   */
+  pythonTestName(name) {
+    return name
+      .replace(/([A-Z])/g, '_$1')
+      .replace(/-/g, '_')
+      .replace(/ /g, '_')
+      .toLowerCase()
+      .replace(/^_/, '')
+      .replace(/__+/g, '_');
+  }
+
+  /**
+   * Find Python test function by name
+   */
+  findPythonTestByName(lines, testName) {
+    const testRegex = new RegExp(`^def test_${testName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*\\(`);
+    return lines.findIndex(line => testRegex.test(line.trim()));
+  }
+
+  /**
+   * Find end of Python function (next def/class or end of file)
+   */
+  findPythonTestEnd(lines, startIndex) {
+    // Find next function or class definition at same or lower indentation level
+    const startLine = lines[startIndex];
+    const startIndent = startLine.match(/^\s*/)[0].length;
+
+    for (let i = startIndex + 1; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+
+      // Skip empty lines and comments
+      if (trimmed === '' || trimmed.startsWith('#')) {
+        continue;
+      }
+
+      const currentIndent = lines[i].match(/^\s*/)[0].length;
+
+      // If we find a def or class at same or lower indentation, function has ended
+      if (currentIndent <= startIndent && (trimmed.startsWith('def ') || trimmed.startsWith('class '))) {
+        return i;
+      }
+    }
+
+    return lines.length;
+  }
 }