GitLab Orbit prompt examples

Using GitLab Orbit, review merge request <!769> in <my-group>/<my-project>.
Back every finding with a query result, not a guess from the diff:
1. Which definitions does it change, and which callers of those
   definitions are outside the merge request? Give the file and line.
2. Which projects in <my-group> import the changed package, and how many
   files in each?
3. Which other open merge requests change the same files?
Then list the risks, each with the result that shows it.

MATCH (mr:MergeRequest {iid: 769, project_id: 9438583})
  -[:HAS_LATEST_DIFF]->(d:MergeRequestDiff)
  -[:HAS_FILE]->(f:MergeRequestDiffFile)
RETURN f.old_path, f.new_path, f.diff
LIMIT 100

MATCH (caller:Definition)
  -[:CALLS]->(d:Definition)
  <-[:DEFINES]-(f:File {project_id: 9438583, branch: 'master'})
WHERE f.path = 'v2/log/log.go'
  AND d.fqn IN ['log.NewWithConfig', 'log.applyConfigOverrides']
  AND NOT caller.file_path IN ['v2/log/log.go', 'v2/log/log_test.go', 'v2/log/doc.go']
RETURN d.fqn, d.start_line, caller.fqn, caller.file_path, caller.start_line
LIMIT 100

MATCH (s:ImportedSymbol {import_path: 'gitlab.com/gitlab-org/labkit/v2/log'})
  <-[:IMPORTS]-(f:File)
  -[:ON_BRANCH]->(b:Branch)
  <-[:CONTAINS]-(p:Project)
WHERE p.full_path STARTS WITH 'gitlab-org/' AND p.id <> 9438583 AND b.is_default = true
RETURN p.full_path, count(f) AS files
ORDER BY files DESC
LIMIT 100

MATCH (mr:MergeRequest)
  -[:HAS_LATEST_DIFF]->(d:MergeRequestDiff)
  -[:HAS_FILE]->(f:MergeRequestDiffFile {project_id: 9438583})
WHERE mr.state = 'opened'
  AND f.old_path IN ['v2/log/log.go', 'v2/log/doc.go']
RETURN mr.iid, mr.title, f.old_path
LIMIT 50

Using GitLab Orbit, for <CVE-2025-58183> in <my-group>:
1. Which projects have open vulnerabilities for the CVE?
2. Which fixes for it reached <production>?
3. For each project with no fix in production, create an issue and start
   an agent session to fix it.

MATCH (v:Vulnerability)-[:HAS_FINDING]->(o:VulnerabilityOccurrence)
  -[:HAS_IDENTIFIER]->(i:VulnerabilityIdentifier {external_id: 'CVE-2025-58183'})
MATCH (v)-[:IN_PROJECT]->(p:Project)
WHERE p.full_path STARTS WITH 'gitlab-org/'
RETURN p.full_path, v.id, v.state, v.severity
ORDER BY p.full_path
LIMIT 50

MATCH (v:Vulnerability)
  <-[:FIXES]-(mr:MergeRequest)
  -[:DEPLOYED_TO]->(d:Deployment)
  -[:IN_ENVIRONMENT]->(e:Environment {tier: 'production'})
MATCH (v)-[:IN_PROJECT]->(p:Project)
WHERE v.id IN [236746171, 234672550, 241357118, 241981811, 234562423, 234562740, 234563175]
RETURN p.full_path, v.id, mr.iid, d.status
LIMIT 50

Using GitLab Orbit, <app/models/ci/> in <my-group>/<my-project> throws errors
in <production>:
1. Which merge requests that changed it reached production in the last
   <seven days>, and when was each deployed?
2. Which components does <app/models/ci/build.rb> call, and which of them
   changed in production deployments in the same window?
Then rank the changes by how likely they are to cause the errors.

MATCH (f:MergeRequestDiffFile)
  <-[:HAS_FILE]-(md:MergeRequestDiff)
  <-[:HAS_LATEST_DIFF]-(mr:MergeRequest)
  -[:DEPLOYED_TO]->(d:Deployment)
  -[:IN_ENVIRONMENT]->(e:Environment {name: 'gprd'})
WHERE mr.project_id = 278964 AND d.created_at >= '2026-10-17T00:00:00Z'
  AND f.old_path STARTS WITH 'app/models/ci/'
RETURN d.created_at, mr.iid, f.old_path
ORDER BY d.created_at DESC
LIMIT 50

MATCH (f:File {path: 'app/models/ci/build.rb', project_id: 278964, branch: 'master'})
  -[:DEFINES]->(d:Definition)
  -[:CALLS]->(callee:Definition)
  <-[:DEFINES]-(cf:File)
WHERE cf.branch = 'master'
RETURN cf.path, count(callee) AS calls
ORDER BY calls DESC
LIMIT 20

Using GitLab Orbit, before I change <BasePolicy> and <Ability::allowed?> in
<my-group>/<my-project>:
1. Which classes inherit from <BasePolicy>, directly or through other
   classes?
2. Which definitions call <Ability::allowed?>?
3. If the code is in a library, which projects in <my-group> import
   <gitlab.com/my-group/my-sdk> on their default branch?

MATCH (child:Definition)
  -[:EXTENDS*1..3]->(parent:Definition {
    fqn: 'BasePolicy', project_id: 278964, branch: 'master'})
RETURN child.fqn, child.file_path
ORDER BY child.file_path
LIMIT 500

MATCH (caller:Definition)
  -[:CALLS]->(d:Definition {
    fqn: 'Ability::allowed?', project_id: 278964, branch: 'master'})
RETURN caller.fqn, caller.file_path, caller.start_line
ORDER BY caller.file_path
LIMIT 1000

MATCH (s:ImportedSymbol)
  <-[:IMPORTS]-(f:File)
  -[:ON_BRANCH]->(b:Branch)
  <-[:CONTAINS]-(p:Project)
WHERE s.import_path STARTS WITH 'gitlab.com/gitlab-org/labkit'
  AND p.full_path STARTS WITH 'gitlab-org/'
  AND b.is_default = true
RETURN p.full_path, count(s) AS import_sites
ORDER BY import_sites DESC
LIMIT 200

Using GitLab Orbit, for merge requests that GitLab Duo agents and flows
created in <my-group>/<my-project> in the last <30 days>:
- What share merged, by flow type, and what is the median time from
  creation to merge?
- Which ones are still open after two weeks, and is their head pipeline
  failing?

MATCH (a:AgentSession)
  -[:CREATED_MR]->(mr:MergeRequest)
WHERE mr.project_id = 278964 AND mr.created_at >= '2026-09-24T00:00:00Z'
RETURN a.flow_type, mr.state, count(mr) AS mrs
ORDER BY mrs DESC
LIMIT 30

MATCH (a:AgentSession)
  -[:CREATED_MR]->(mr:MergeRequest)
WHERE mr.project_id = 278964 AND mr.created_at >= '2026-09-24T00:00:00Z'
  AND mr.state = 'merged'
RETURN a.flow_type, mr.iid, mr.created_at, mr.merged_at
LIMIT 1000

MATCH (a:AgentSession)
  -[:CREATED_MR]->(mr:MergeRequest)
  -[:HAS_HEAD_PIPELINE]->(pl:Pipeline {status: 'failed'})
WHERE mr.project_id = 278964 AND mr.state = 'opened'
  AND mr.created_at >= '2026-09-24T00:00:00Z' AND mr.created_at < '2026-10-10T00:00:00Z'
RETURN mr.iid, mr.title, a.flow_type
LIMIT 100

Using GitLab Orbit, which projects in <my-group> ran pipelines in the last
<30 days> but no <SAST>, <dependency scanning>, or <secret detection> scan?

MATCH (pl:Pipeline)-[:IN_PROJECT]->(p:Project)
WHERE p.full_path STARTS WITH 'gitlab-org/ci-cd/' AND pl.created_at >= '2026-09-24T00:00:00Z'
RETURN p.full_path, count(pl) AS pipelines
LIMIT 1000

MATCH (s:SecurityScan)-[:IN_PROJECT]->(p:Project)
WHERE p.full_path STARTS WITH 'gitlab-org/ci-cd/' AND s.created_at >= '2026-09-24T00:00:00Z'
  AND s.status = 'succeeded'
RETURN p.full_path, s.scan_type, count(s) AS scans
LIMIT 1000

Using GitLab Orbit, my merge request in <my-group>/<my-project> fails the
job <docs-lint markdown>. Is it my change or a flaky job?
- How often did the job pass on <master> in the last <14 days>, and how
  did it fail?
- Which other open merge requests fail the job now?
- Which projects in <my-group> failed the job in the last <seven days>,
  and how many times each?

MATCH (j:Job {project_id: 278964, name: 'docs-lint markdown', ref: 'master'})
WHERE j.created_at >= '2026-10-10T00:00:00Z'
RETURN j.status, j.failure_reason, count(j) AS jobs
ORDER BY jobs DESC
LIMIT 10

MATCH (mr:MergeRequest {project_id: 278964, state: 'opened'})
  -[:HAS_HEAD_PIPELINE]->(pl:Pipeline)
  -[:HAS_JOB]->(j:Job {name: 'docs-lint markdown', status: 'failed'})
RETURN mr.iid, mr.title, j.failure_reason, j.created_at
ORDER BY j.created_at DESC
LIMIT 20

MATCH (j:Job {status: 'failed', name: 'docs-lint markdown'})
  -[:IN_PROJECT]->(p:Project)
WHERE p.full_path STARTS WITH 'gitlab-org/'
  AND j.created_at >= '2026-10-17T00:00:00Z'
RETURN p.full_path, count(j) AS failures
ORDER BY failures DESC
LIMIT 20

Using GitLab Orbit, for the open merge requests in milestone <19.6> of
<my-group>/<my-project> that have a failed head pipeline:
- Which failed jobs do they have in common?
- Who is assigned to the merge requests that fail each job?

MATCH (mr:MergeRequest {project_id: 278964, state: 'opened'})
  -[:IN_MILESTONE]->(m:Milestone {title: '19.6'})
MATCH (mr)-[:HAS_HEAD_PIPELINE]->(pl:Pipeline {status: 'failed'})
  -[:HAS_JOB]->(j:Job {status: 'failed', allow_failure: false, retried: false})
WHERE pl.created_at >= '2026-10-17T00:00:00Z'
RETURN j.name, mr.iid
ORDER BY j.name
LIMIT 1000

MATCH (u:User)
  -[:ASSIGNED]->(mr:MergeRequest {project_id: 278964, state: 'opened'})
  -[:IN_MILESTONE]->(m:Milestone {title: '19.6'})
MATCH (mr)-[:HAS_HEAD_PIPELINE]->(pl:Pipeline {status: 'failed'})
  -[:HAS_JOB]->(j:Job {name: 'e2e:test-on-cng', status: 'failed', allow_failure: false, retried: false})
WHERE pl.created_at >= '2026-10-17T00:00:00Z'
RETURN u.username, count(mr) AS mrs
ORDER BY mrs DESC
LIMIT 20

Using GitLab Orbit, in <my-group>/<my-project>:
- What did reviewers say about <N+1 queries> on the merge requests that
  changed <app/models/ability.rb>?
- Who approved those merge requests?

MATCH (n:Note)
  <-[:HAS_NOTE]-(mr:MergeRequest)
  -[:HAS_LATEST_DIFF]->(d:MergeRequestDiff)
  -[:HAS_FILE]->(f:MergeRequestDiffFile {
    project_id: 278964, old_path: 'app/models/ability.rb'})
WHERE n.note CONTAINS 'N+1'
RETURN mr.iid, n.note
ORDER BY mr.iid DESC
LIMIT 20

MATCH (u:User)
  -[:APPROVED]->(mr:MergeRequest {state: 'merged'})
  -[:HAS_LATEST_DIFF]->(d:MergeRequestDiff)
  -[:HAS_FILE]->(f:MergeRequestDiffFile {project_id: 278964, old_path: 'app/models/ability.rb'})
RETURN u.username, count(mr) AS approvals
ORDER BY approvals DESC
LIMIT 10