start_codegen_session

Initiates a code generation session to record Playwright automation actions, saving tests to a specified directory with optional test name prefixes and comments.

Instructions

Start a new code generation session to record Playwright actions

Input Schema

TableJSON Schema

Name	Required	Description	Default
`options`	Yes	Code generation options

Implementation Reference

src/tools/codegen/index.ts:25-80 (handler)

Defines and implements the 'start_codegen_session' tool including its handler function that initializes a new code generation session by merging options, creating output directories, and starting an ActionRecorder session.

export const startCodegenSession: Tool = {
  name: 'start_codegen_session',
  description: 'Start a new code generation session to record MCP tool actions',
  parameters: {
    type: 'object',
    properties: {
      options: {
        type: 'object',
        description: 'Code generation options',
        properties: {
          outputPath: { type: 'string' },
          testNamePrefix: { type: 'string' },
          includeComments: { type: 'boolean' }
        }
      }
    }
  },
  handler: async ({ options = {} }: { options?: CodegenOptions }) => {
    try {
      // Merge provided options with defaults
      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
      
      // Ensure output path is absolute and normalized
      const workspaceRoot = getWorkspaceRoot();
      const outputPath = path.isAbsolute(mergedOptions.outputPath) 
        ? mergedOptions.outputPath 
        : path.join(workspaceRoot, mergedOptions.outputPath);
      
      mergedOptions.outputPath = outputPath;
      
      // Ensure output directory exists
      try {
        await fs.mkdir(outputPath, { recursive: true });
      } catch (mkdirError: any) {
        throw new Error(`Failed to create output directory: ${mkdirError.message}`);
      }
      
      const sessionId = ActionRecorder.getInstance().startSession();
      
      // Store options with the session
      const recorder = ActionRecorder.getInstance();
      const session = recorder.getSession(sessionId);
      if (session) {
        session.options = mergedOptions;
      }
      
      return { 
        sessionId,
        options: mergedOptions,
        message: `Started codegen session. Tests will be generated in: ${outputPath}`
      };
    } catch (error: any) {
      throw new Error(`Failed to start codegen session: ${error.message}`);
    }
  }
};

src/tools.ts:7-35 (schema)

MCP input schema definition for the 'start_codegen_session' tool, specifying detailed properties and requirements for the options parameter.

{
  name: "start_codegen_session",
  description: "Start a new code generation session to record Playwright actions",
  inputSchema: {
    type: "object",
    properties: {
      options: {
        type: "object",
        description: "Code generation options",
        properties: {
          outputPath: { 
            type: "string", 
            description: "Directory path where generated tests will be saved (use absolute path)" 
          },
          testNamePrefix: { 
            type: "string", 
            description: "Prefix to use for generated test names (default: 'GeneratedTest')" 
          },
          includeComments: { 
            type: "boolean", 
            description: "Whether to include descriptive comments in generated tests" 
          }
        },
        required: ["outputPath"]
      }
    },
    required: ["options"]
  }
},

src/toolHandler.ts:364-372 (registration)

Registration and dispatching logic in the main tool handler switch statement that routes 'start_codegen_session' calls to its handler function.

switch (name) {
  case 'start_codegen_session':
    return await handleCodegenResult(startCodegenSession.handler(args));
  case 'end_codegen_session':
    return await handleCodegenResult(endCodegenSession.handler(args));
  case 'get_codegen_session':
    return await handleCodegenResult(getCodegenSession.handler(args));
  case 'clear_codegen_session':
    return await handleCodegenResult(clearCodegenSession.handler(args));

src/tools/codegen/index.ts:28-41 (schema)

Internal parameters schema defined within the Tool object for 'start_codegen_session'.

parameters: {
  type: 'object',
  properties: {
    options: {
      type: 'object',
      description: 'Code generation options',
      properties: {
        outputPath: { type: 'string' },
        testNamePrefix: { type: 'string' },
        includeComments: { type: 'boolean' }
      }
    }
  }
},

src/toolHandler.ts:7-12 (registration)
Import statement registering the codegen tools including 'start_codegen_session' for use in the tool handler.
```
import { 
  startCodegenSession,
  endCodegenSession,
  getCodegenSession,
  clearCodegenSession
} from './tools/codegen/index.js';
```

mcp-playwright