FilesExpand file tree

github

/

softwareDeveloperAgent.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

103 lines (88 loc) · 4.62 KB

github

/

softwareDeveloperAgent.ts

Copy path

Top

File metadata and controls

• Code
• Blame

103 lines (88 loc) · 4.62 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

import { getFileSystem } from '#agent/agentContext';

import { GitLabProject } from '#functions/scm/gitlab';

import { getSourceControlManagementTool } from '#functions/scm/sourceControlManagement';

import { logger } from '#o11y/logger';

import { span } from '#o11y/trace';

import { createBranchName } from '#swe/createBranchName';

import { generatePullRequestTitleDescription } from '#swe/pullRequestTitleDescription';

import { selectProject } from '#swe/selectProject';

import { summariseRequirements } from '#swe/summariseRequirements';

import { ExecResult, execCommand, failOnError } from '#utils/exec';

import { cacheRetry } from '../cache/cacheRetry';

import { func, funcClass } from '../functionDefinition/functionDecorators';

import { CodeEditingAgent } from './codeEditingAgent';

import { ProjectInfo, detectProjectInfo } from './projectDetection';

import { basePrompt } from './prompt';

export function buildPrompt(args: {

information: string;

requirements: string;

action: string;

}): string {

return `${basePrompt}' + ${args.information}\n\nThe requirements of the task are as follows:\n<requirements>\n${args.requirements}\n</requirements>\n\nThe action to be performed is as follows:\n<action>\n${args.action}\n</action>\n`;

}

/**

* Workflow for completing requirements. This will look up the appropriate project in source control, clone, make the changes and create a pull/merge request.

* Assumes the SCM is set on the workflow context

*/

@funcClass(__filename)

export class SoftwareDeveloperAgent {

/**

* Runs the software developer agent to complete the user request/requirements. This will find the appropriate Git project/repository, clone it, make the changes, compile and test if applicable, commit and create a pull/merge request to review.

* @param requirements the requirements to implement. Provide ALL the details that might be required by this agent to complete the requirements task.

*/

@func()

async runSoftwareDeveloperWorkflow(requirements: string): Promise<void> {

const requirementsSummary = await this.summariseRequirements(requirements);

const gitProject = await this.selectProject(requirementsSummary);

const targetBranch = gitProject.default_branch;

const repoPath = await getSourceControlManagementTool().cloneProject(gitProject.path_with_namespace);

getFileSystem().setWorkingDirectory(repoPath);

const projectInfo = await this.detectSingleProjectInfo();

if (projectInfo.initialise) {

const result: ExecResult = await execCommand(projectInfo.initialise);

failOnError('Error initialising the repository project', result);

}

// Should check we're on the develop/default branch first, and pull, when creating a branch

// If we're resuming an agent which has progressed past here then it will switch to the branch it created before

const branchName = await this.createBranchName(requirements);

await getFileSystem().vcs.switchToBranch(branchName);

await new CodeEditingAgent().runCodeEditWorkflow(requirementsSummary, projectInfo);

const { title, description } = await generatePullRequestTitleDescription(requirements);

await getSourceControlManagementTool().createMergeRequest(title, description, branchName, targetBranch);

}

@cacheRetry({ scope: 'agent' })

@span()

async createBranchName(requirements: string, issueId?: string): Promise<string> {

// We always want the agent to use the same branch name when its resumed/retrying, so we cache it in the agent scope

return await createBranchName(requirements, issueId);

}

/**

* Summarises/re-writes the requirements in a clear, structured manner from the perspective of a software developer who needs is doing the implementation

* @param requirements the requirements to implement

*/

@cacheRetry()

@span()

async summariseRequirements(requirements: string): Promise<string> {

return await summariseRequirements(requirements);

}

@cacheRetry({ scope: 'agent' })

@span()

async selectProject(requirements: string): Promise<GitLabProject> {

return await selectProject(requirements);

}

// @cacheRetry()

async detectProjectInfo(): Promise<ProjectInfo[]> {

return await detectProjectInfo();

}

/**

* A projectInfo.json file may have references to sub-projects. Calling this method assumes

* there will be only one entry in the projectInfo.json file, and will throw an error if there is more

*/

async detectSingleProjectInfo(): Promise<ProjectInfo> {

const projectInfos = await this.detectProjectInfo();

if (projectInfos.length !== 1) throw new Error('detected project info length != 1');

const projectInfo = projectInfos[0];

logger.info(projectInfo, `Detected project info ${Object.keys(projectInfo).join(', ')}`);

return projectInfo;

}

}