overseer.generate_ci

Generate CI/CD pipeline configurations for GitHub Actions, GitLab CI, CircleCI, or Jenkins based on project phase definitions to automate testing and deployment workflows.

Instructions

Generates CI/CD pipeline configuration (GitHub Actions, GitLab CI, etc.) based on phase definitions.

Input Schema

TableJSON Schema

Name	Required	Description
`repo_name`	Yes	Name of the repository
`ci_type`	Yes	Type of CI/CD system to generate
`options`	No

Implementation Reference

src/tools/generate-ci.ts:41-67 (handler)

The handleGenerateCi function that executes the tool logic for overseer.generate_ci (currently a stub implementation planned for v1.1).

export async function handleGenerateCi(
  args: {
    repo_name: string;
    ci_type: 'github-actions' | 'gitlab-ci' | 'circleci' | 'jenkins';
    options?: {
      run_tests?: boolean;
      deploy_on_complete?: boolean;
    };
  },
  phaseManager: PhaseManager
): Promise<{
  success: boolean;
  files_created: string[];
  pipeline_config: Record<string, unknown>;
  message?: string;
}> {
  // Note: generate_ci is a planned feature for v1.1+
  // This tool will generate CI/CD pipeline configurations based on
  // phase definitions and project structure
  
  return {
    success: true,
    files_created: [],
    pipeline_config: {},
    message: `CI/CD generation for ${args.ci_type} is planned for v1.1.0. This tool will create pipeline configurations based on phase definitions and project structure.`,
  };
}

src/tools/generate-ci.ts:4-39 (schema)

Factory function createGenerateCiTool that defines the tool's name, description, and inputSchema.

export function createGenerateCiTool(phaseManager: PhaseManager): Tool {
  return {
    name: 'overseer.generate_ci',
    description: 'Generates CI/CD pipeline configuration (GitHub Actions, GitLab CI, etc.) based on phase definitions.',
    inputSchema: {
      type: 'object',
      required: ['repo_name', 'ci_type'],
      properties: {
        repo_name: {
          type: 'string',
          description: 'Name of the repository',
        },
        ci_type: {
          type: 'string',
          enum: ['github-actions', 'gitlab-ci', 'circleci', 'jenkins'],
          description: 'Type of CI/CD system to generate',
        },
        options: {
          type: 'object',
          properties: {
            run_tests: {
              type: 'boolean',
              default: true,
              description: 'Include test steps in pipeline',
            },
            deploy_on_complete: {
              type: 'boolean',
              default: false,
              description: 'Include deployment steps',
            },
          },
        },
      },
    },
  };
}

src/tools/index.ts:22-41 (registration)

The createTools function registers the overseer.generate_ci tool by calling createGenerateCiTool and including it in the tools array.

export function createTools(context: ToolContext): Tool[] {
  return [
    // Planning tools
    createPlanProjectTool(context.phaseManager),
    createInferPhasesTool(context.configLoader),
    createUpdatePhasesTool(context.phaseManager),
    // Execution tools
    createRunPhaseTool(context.phaseManager),
    createAdvancePhaseTool(context.phaseManager),
    createStatusTool(context.phaseManager),
    // QA tools
    createLintRepoTool(context.configLoader),
    createSyncDocsTool(context.phaseManager),
    createCheckComplianceTool(context.phaseManager),
    // Environment tools
    createEnvMapTool(context.phaseManager),
    createGenerateCiTool(context.phaseManager),
    createSecretsTemplateTool(context.phaseManager),
  ];
}

src/tools/index.ts:43-80 (registration)

The handleToolCall function dispatches calls to overseer.generate_ci by invoking handleGenerateCi in its switch case.

export async function handleToolCall(
  name: string,
  args: any,
  context: ToolContext
): Promise<any> {
  switch (name) {
    // Planning tools
    case 'overseer.plan_project':
      return await handlePlanProject(args, context.phaseManager);
    case 'overseer.infer_phases':
      return await handleInferPhases(args, context.configLoader);
    case 'overseer.update_phases':
      return await handleUpdatePhases(args, context.phaseManager);
    // Execution tools
    case 'overseer.run_phase':
      return await handleRunPhase(args, context.phaseManager);
    case 'overseer.advance_phase':
      return await handleAdvancePhase(args, context.phaseManager);
    case 'overseer.status':
      return await handleStatus(args, context.phaseManager);
    // QA tools
    case 'overseer.lint_repo':
      return await handleLintRepo(args, context.configLoader);
    case 'overseer.sync_docs':
      return await handleSyncDocs(args, context.phaseManager);
    case 'overseer.check_compliance':
      return await handleCheckCompliance(args, context.phaseManager);
    // Environment tools
    case 'overseer.env_map':
      return await handleEnvMap(args, context.phaseManager);
    case 'overseer.generate_ci':
      return await handleGenerateCi(args, context.phaseManager);
    case 'overseer.secrets_template':
      return await handleSecretsTemplate(args, context.phaseManager);
    default:
      throw new Error(`Unknown tool: ${name}`);
  }
}

Overseer MCP Server