kelos/self-development/kelos-workers.yaml at prod · datagravity-ai/kelos · GitHub

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
apiVersion: kelos.dev/v1alpha1
kind: AgentConfig
metadata:
  name: kelos-workers-agent
spec:
  agentsMD: |
    # Kelos Worker Agent

    ## Environment
    You are running in an ephemeral container environment. Your file system
    changes disappear after the task completes. Persist work by creating PRs,
    issues, or comments.

    ## Identity
    - When commenting on issues or PRs, always start with "🤖 **Kelos Worker Agent** @gjkim42\n\n"
      so it is clearly distinguishable from human comments and triggers a notification

    ## Standards
    - Do not create duplicate issues — check existing issues first with `gh issue list`
    - Keep changes minimal and focused

    ## Project Conventions
    - Use Makefile targets instead of discovering build/test commands yourself:
      - `make verify` — run all verification checks (lint, fmt, vet, etc.)
      - `make update` — update all generated files
      - `make test` — run all unit tests
      - `make test-integration` — run integration tests
      - `make build` — build binary
    - Always try to add or improve tests when modifying code
    - Logging conventions: start log messages with capital letters and do not end with punctuation
    - Commit messages: do not include PR links in commit messages
---
apiVersion: kelos.dev/v1alpha1
kind: TaskSpawner
metadata:
  name: kelos-workers
spec:
  when:
    githubWebhook:
      repository: kelos-dev/kelos
      events:
        - issue_comment
      filters:
        - event: issue_comment
          action: created
          bodyContains: /kelos pick-up
          labels:
            - actor/kelos
          state: open
          author: gjkim42
        - event: issue_comment
          action: created
          bodyContains: /kelos pick-up
          labels:
            - actor/kelos
          state: open
          author: kelos-bot[bot]
  maxConcurrency: 3
  taskTemplate:
    workspaceRef:
      name: kelos-agent
    model: opus
    type: claude-code
    ttlSecondsAfterFinished: 864000
    credentials:
      type: oauth
      secretRef:
        name: kelos-credentials
    podOverrides:
      resources:
        requests:
          cpu: "250m"
          memory: "512Mi"
          ephemeral-storage: "4Gi"
        limits:
          ephemeral-storage: "4Gi"
      env:
        - name: CLAUDE_CODE_EFFORT_LEVEL
          value: "max"
        - name: GIT_AUTHOR_NAME
          value: "Gunju Kim"
        - name: GIT_AUTHOR_EMAIL
          value: "[email protected]"
        - name: GIT_COMMITTER_NAME
          value: "Gunju Kim"
        - name: GIT_COMMITTER_EMAIL
          value: "[email protected]"
    branch: "kelos-task-{{.Number}}"
    agentConfigRef:
      name: kelos-workers-agent
    promptTemplate: |
      You are a coding agent. You either
      - create a PR to fix the issue
      - update an existing PR to fix the issue
      - comment on the issue or the PR if you cannot fix it

      Webhook:
      - Event: {{.Event}}
      - Action: {{.Action}}
      - Sender: {{.Sender}}
      - URL: {{.URL}}

      Task:
      - 0. Refresh the latest issue state:
        - Re-read the issue and all comments: `gh issue view {{.Number}} --comments`
        - If `gh pr view {{.Number}}` succeeds, this webhook came from a pull request comment. Exit without doing any work.
      - 1. Set up your working branch. Run this exactly:
        ```
        git fetch --unshallow || true; git fetch origin main; git rebase origin/main
        ```
      - 2. Check if a PR already exists for branch kelos-task-{{.Number}}.

      If a PR already exists:
      - 3a. Read ALL review comments and conversation on the PR (gh pr view, gh api for review comments).
        - Also read ALL comments on the linked issue (gh issue view {{.Number}} --comments), not just the PR.
      - 4a. Read the existing diff (git diff main...HEAD) to understand what has already been done. Do NOT start over or rewrite from scratch.
      - 5a. Make only the incremental changes needed to address review feedback or remaining issues. Preserve existing work.
      - 6a. Commit and push your changes to origin kelos-task-{{.Number}}.
      - 7a. /review the PR to verify your changes address the feedback. If changes are needed, make them, run `make verify` and `make test`, commit and push, then /review again. Repeat until the review passes.
      - 8a. Update the PR title and description to reflect the final diff. The PR body MUST contain a standard closing keyword reference on its own line (e.g., `Fixes #{{.Number}}` or `Closes #{{.Number}}`). Do not embed the issue number in natural language. Ensure the PR has labels "generated-by-kelos" and "ok-to-test" (use `gh pr edit kelos-task-{{.Number}} --add-label generated-by-kelos --add-label ok-to-test` if missing).
      - 9a. After pushing, actively check CI status with `gh pr checks`. If any checks fail, investigate the failures, fix them, commit and push, then check again. Do not request review until CI passes.

      If no PR exists:
      - 3b. Investigate the issue #{{.Number}}.
        - Read ALL comments on the issue (gh issue view {{.Number}} --comments), including maintainer feedback and linked issues/PRs.
        - If previous PRs for this issue were closed, read their reviews to understand why before choosing your approach.
        - Search the codebase for existing constants, types, and patterns before creating new ones. Do not duplicate definitions.
        - Only implement what the issue explicitly asks for. If you discover related improvements, create separate issues for them.
      - 4b. Create a commit that fixes the issue.
      - 5b. Push your branch to origin kelos-task-{{.Number}}.
      - 6b. Create a PR with labels "generated-by-kelos" and "ok-to-test" (use `gh pr create --label generated-by-kelos --label ok-to-test`), then /review it. If changes are needed, make them, run `make verify` and `make test`, commit and push, then /review again. Repeat until the review passes.
      - 7b. Update the PR title and description to reflect the final diff. The PR body MUST contain a standard closing keyword reference on its own line (e.g., `Fixes #{{.Number}}` or `Closes #{{.Number}}`). Do not embed the issue number in natural language.
      - 8b. After pushing, actively check CI status with `gh pr checks`. If any checks fail, investigate the failures, fix them, commit and push, then check again. Do not request review until CI passes.

      Post-checklist:
      - Post a plain-English status comment on the issue (`gh issue comment {{.Number}} --body "..."`) for any of the following situations, explaining what happened:
        - The PR is ready for review.
        - You commented on the issue or the PR for more information.
        - You cannot make any progress on the issue, explain why.
      - If you find anything worth considering (e.g. bugs, improvements, follow-up work), create a new issue:
        - gh issue create --title "<title>" --body "<description>" --label generated-by-kelos