<img src="https://raw.githubusercontent.com/shashankcube/image/main/github-automation.png" align="center"/> 
 
Connect GitHub with DevRev, and ensure your work stays in sync between the two systems, such that issues and statuses are always real-time and driven by code activity. GitHub for DevRev is a snap-in that has been used by several organizations, and ties DevRev issues closely with GitHub activity, eliminating the need for humans to manage issues.

Why should you un-manage your work? You should use this snap-in if you want to reduce work about work. Let machines manage issues, including creating and updating statuses, so developers can focus on work that matters. You’ll resonate with this, if you have ever:

- Delivered a hot-patch and realized you never had an issue to track it
- Wasted time just updating your team on the status of an issue
- Or just felt that creating and managing issues is a distraction

If your team’s best practice is to link your GitHub activity to an existing issue-ID during branch creation, commits and PRs, then this snap-in will honor that and enable a GitHub driven issue state, without auto creating issues. [Here](https://devrev.ai/docs/integrations/github#github-events) are the different ways you can link your DevRev issue to GitHub branches, commits and PRs. 

However, if you choose to work in GitHub and never created or linked an issue, you shouldn’t have to sweat it. This snap-in will automatically create issues that track all associated commits, branches and pull requests. The auto-created issue is enriched with PR description and related GitHub events. The status of these issues is driven by GitHub activity, and the issues will auto-transition stages, from In Development to In Review, and Closed. Your work is always accounted for and more importantly your team members have visibility and know what you’ve been up to, resulting in fewer interruptions. 

## How it works

To enable GitHub for DevRev, click on Install and we'll walk you through a few simple steps including connecting with GitHub. You'll have a default set of configuration settings and the option to further personalize this snap-in. Learn more about the features in this snap-in.

## Features
This snap-in is powerful, and has several configurable features. As they say, the power is in the defaults! When you install this snap-in, we'll configure defaults that are tried and tested. You always have the option to personalize further.

**Automatic status updates**

You can associate GitHub commits, branches and pull requests with the DevRev issue they correspond to. Doing so allows you to see GitHub activity in the corresponding DevRev issue and to act on those events, allowing you to automate away your manual tasks. Mention DevRev issues in GitHub, and route the relevant GitHub events to this issue. They can be mentioned either as display IDs (ISS-34) or object IDs (issue:34), case insensitively. A DevRev issue can be mentioned in branch names, commit messages or PR titles.

**Autocreate issues from GitHub branch**

If you do not explicitly associate your DevRev issue to GitHub branches, commits or PRs, then we can autocreate your issues so you have an account of all your GitHub activity. This feature automatically creates an issue when a new branch is created, and tracks all associated commits and Pull Requests on this issue. The auto-created issues will move status based on Git activity, to in development based on branch and commit activity, and in review when PRs are created. When PRs are merged, the issue will be automatically closed, though this behavior is configurable.

**Autocreate issues from GitHub PRs**

You can choose to automatically create issues when a new PR is created, and it is not linked to an existing DevRev Issue. The behavior is similar to how issues are auto-created with new branches. The auto-created issues will move status based on Git activity, and events are posted on the DevRev issue timeline. It is recommended you enable either one of `Autocreate issue from GitHub branch` or `Autocreate issue from GitHub PR`, but not both.

Issues autocreated from GitHub branches or PRs are called autonomous issues, and have the tag `autonomous`.

**Attribute part to autonomous work**

Autonomous issues originating from GitHub will be attributed to a default part. You can configure the default part while setting up your snap-in. Every issue in DevRev must have a part attribution.

**Enrich autonomous work descriptions**

Enrich autonomous issues with information derived from GitHub PR events. The title and description of an autocreated issue is enriched with the PR data. When a new GitHub PR is opened or edited, then the related autonomous issue description is updated with the latest PR description. If the user has removed the auto generated text, then the automation will no longer update the description from PRs. Similarly, autonomous work titles are updated with the PR title, if the user hasn’t already updated it.

**Link autonomous work with related issue**

Create a related link between the work-items mentioned in the PR body and the autonomous issues tagged with the branch/PR. When a new GitHub PR is opened/edited, for all the autonomous tagged work items(by branch/PR), automatically mark the issues mentioned in the PR as related.

**Automatically close autonomous work**

Autonomous work gets closed when its related PR is merged. However, if there is no PR activity on this work, then the autonomous work is closed after configurable period.

**GitHub Commands**

Enable quick actions to close or attribute a PR to DevRev issue(s) with slash command.

* `/towards` - Use the `/towards` command in the PR description to associate the related GitHub activity to the issue(s). This will ensure that the PR and issue are linked such that related events are posted and issue status is driven by GitHub events.

* `/close {work-id}` - Use `/close ISS-3 ISS-4` in a PR body to automatically close a specific issue(s) when the PR is merged. You can also use `/close #work` to close all associated issues with a PR when that PR is merged without knowing the specific ids.

**Automatic PR tasks**

When a pull request is requested or reopened, a DevRev task is created for you. In order for this automation to be triggerred, you'll need to link your Pull Requests to DevRev issues. If your PR is removed, merged or closed, then the Task gets deleted. However, if you submit your PR review, then the task is closed.

**Automatic PR reminders**

When a pull request is inactive for more than a specified number of days, then this automation will post a message in all related DevRev issues. You'll need to link your GitHub Pull Request to DevRev issue to enable these reminders. There are several ways to link your GitHub Pull Requests to DevRev Issues. You can do so by mentioning the DevRev issue-id in Pull Requests title or body, or mention it in the branch name or commit message. Reminders are also posted for issues created autonomously.

You can choose to setup the inactive period in number of days through the max_inactive_days setting.

## Installation

For detailed installation and configuration instructions, refer to the [Github documentation](https://docs.devrev.ai/integrations/github).

## **Frequently asked questions** 
<details>
<summary>What is an autonomous issue?</summary> 
Autonomous issue is an issue created automatically from an external event, such as a new GitHub branch or PR. These issues have the tag <code>autonomous</code>.
</details>

<details>
<summary>How does an issue change status?</summary>

<table>
 <tr>
 <td></td>
 <td colspan="2" align="center">Stage</td>
 </tr>
 <tr>
 <td></td>
 <td>From</td>
 <td>To</td>
 </tr>
 <tr>
 <td>New branch</td>
 <td>Any but not closed status</td>
 <td>In development</td>
 </tr>
 <tr>
 <td>Commit pushed</td>
 <td>No change</td>
 <td></td>
 </tr>
 <tr>
 <td>PR opened</td>
 <td>Any but not closed status</td>
 <td>In review</td>
 </tr>
 <tr>
 <td>PR closed</td>
 <td>In review</td>
 <td>In development</td>
 </tr>
 <tr>
 <td>PR reopened</td>
 <td>Any but not closed status</td>
 <td>In review</td>
 </tr>
 <tr>
 <td>*PR merged (without /close)</td>
 <td>In review</td>
 <td>In development</td>
 </tr>
 <tr>
 <td>PR merged (with /close)</td>
 <td>Any but not closed status</td>
 <td>Resolved</td>
 </tr>
</table>
 *This change happens only when <code>change_stage_to_in_development_on_pr_close</code> is true

</details>

<details>
<summary>What are the autonomous work configuration options?</summary>

<table>
 <tr>
 <td>Parameter</td>
 <td>Value</td>
 <td>Description</td>
 </tr>
 <tr>
 <td><code>create_work_item_on_new_branch</code></td>
 <td>Enabled or disabled</td>
 <td>Creates autonomous work items on a new branch when no work-id is mentioned</td>
 </tr>
 <tr>
 <td><code>create_work_item_on_pr_open</code></td>
 <td>Enabled or disabled</td>
 <td>Creates autonomous work items on a new PR, when no work-id is mentioned</td>
 </tr>
 <tr>
 <td><code>mention_work_directly_in_pr_body</code></td>
 <td>Enabled or disabled</td>
 <td>Link work-id to a PR, when its found in PR body</td>
 </tr>
 <tr>
 <td><code>enable_magic_commands</code></td>
 <td>Enabled or disabled</td>
 <td>Use magic commands /close and /toward in your PR</td>
 </tr>
 <tr>
 <td><code>close_autonomous_work_on_merge</code></td>
 <td>Enabled or disabled</td>
 <td>Close the autonomous work when the PR is merged</td>
 </tr>
 <tr>
 <td><code>default_part</code></td>
 <td>part display id</td>
 <td>Autonomous work is created under this default part</td>
 </tr>
 <tr>
 <td><code>update_autonomous_work_from_pr</code></td>
 <td>Enabled or disabled</td>
 <td>Enrich autonomous work item title and description with PR data</td>
 </tr>
 <tr>
 <td><code>link_autonomous_issues_with_pr_mention</code></td>
 <td>Enabled or disabled</td>
 <td>Link the work item mentioned in PR to the autonomous work created</td>
 </tr>
 <tr>
 <td><code>change_stage_to_in_development_on_pr_close</code></td>
 <td>Enabled or disabled</td>
 <td>Autonomous work changes stage to `in_development` when a PR is closed</td>
 </tr>
</table>
</details>

<details>
<summary>How can autonomous work creation be disabled?</summary>
 You can disable the parameters <code>create_work_item_on_new_branch</code> and <code>create_work_item_on_new_PR</code> to not autocreate issues. If you choose to turn this off as an exception, you can choose to begin your branch name or PR title with nw-(e.g, nw-new-branch) 
</details>

<details>
<summary>How can you attribute a part to an autonomous issue?</summary>
This automation will infer the part from a repository, if possible. If not, the issue is created with a specified default part. 
</details>

<details>
<summary>When is the automous issue closed?</summary>
The autonomous work item is automatically closed when its source PR or a PR on its source branch is merged.
</details>

<details>
<summary>What are the prerequisites for scheduling PR reminders?</summary>
This automation is triggered when Pull Requests are linked to DevRev issues. If you have not linked GitHub Pull Requests, then reminders will not be posted.
</details>

<details>
<summary>What are the prerequisites for creating PR tasks?</summary>
You'll need to connect your GitHub identity with DevRev identity, so we can attribute the tasks to your DevRev user identity. You can link your GitHub identity by going to **Settings > Account > External Identities > Link GitHub Account**.
.
</details>

DevRev Marketplace

GitHub

Your issues on Autopilot. Sync GitHub and DevRev so issue and status is always real time and driven by code.

<img alt="image" src="https://user-images.githubusercontent.com/98844776/227121358-6a29ba46-d97a-4f46-84ce-53b6781b8135.png">

Using the slash commands you can access specific actions quickly and use DevRev's Turing AI to perform some out-of-the-box functions.

## How it works

In the Discussion section, enter '/' in the text field to see a list of commands that apply to the source item.


## Commands

**Remind**

Using the remind command, you can set a reminder for yourself or another user in the context of the source. You must specify a time and add messages to set the reminder.

For example: 
`/remind @user Please follow up on this. 1d`

**Rephrase**

The rephrase command helps you reply professionally when communicating with clients or colleagues.

For example: 
`/rephrase can't help now... ask again in 5d`

Sample response:

```
I apologize that I am unable to assist you at the moment, however please reach out to me again in five days and I will be happy to help you.
```

**Summarize**

Using the summarize command, you can sum up the entire conversation. It applies to the following: 
* Conversation
* Tickets
* Issues
* Part
* Workspace
* Rev user
* Account

Syntax: 
`/summarize`

Sample response:

Summary:

- Rahul from DummyOrg is having difficulty installing the Plug Widget.
- Rohan suggests checking the setup instructions.
- When this does not work, Rohan asks for more information on the error.
- Rahul shares a recording of the error.
- Rohan thanks the user, and they get on call to fix it.

**Clone**

Using the clone command, a copy of the selected issue or ticket is created. All attributes of the issue/ticket are copied, along with [CLONE] prefixed to the title. It also comments on: 
* Source issue/ticket. For example, 'ISS-0123 was cloned and ISS-0123 was created.'
* Cloned issue/ticket. For example, 'TKT was cloned from TKT-0123.'

## Installation

For detailed installation and configuration instructions, refer to the [Slash commands documentation](https://docs.devrev.ai/automations/slash-commands).

Slash Commands

Slash commands in DevRev powered by Turing AI for more productivity.

![image](https://user-images.githubusercontent.com/16090899/184037723-ae5ed2be-4ec6-4c99-9872-751cea9a7b2c.png)

The Jira import snap-in enables you to keep track of your work no matter where it happens. You can migrate issues and users for an easier onboarding experience or sync Jira issues so you can leverage both systems.

## How it works

Jira import provides various options for importing and synchronizing issues and users from Jira. Whether you need to import one project or multiple, choose between one-way sync from Jira to DevRev or bi-directional to keep both systems in sync.

## Features

**Recipe mapping**

Recipe mapping ensures no critical Jira fields, even custom ones, are overlooked. You can select what to migrate and let our recommendations guide you on how to optimize the migration process for your Jira projects.

**Import**

The import feature allows for a one-time bulk migration of a Jira project. It utilizes recipe mapping, ensuring you bring over only what's essential and leave unnecessary data behind.

**Sync to DevRev**

Using the sync to DevRev functionality, you can re-synchronize a prior import to incorporate any new issues or modifications to previously imported items from a Jira project.

**Sync to Jira**

The sync to Jira functionality enables you to update modifications made in DevRev to Jira projects that were previously imported. Additionally, you can synchronize new work items created in DevRev to Jira.

## Installation

For detailed installation and configuration instructions, refer to the [Jira import documentation](https://docs.devrev.ai/integrations/jira).


Jira

Bidirectional sync to coexist delightfully with Jira, and transition to DevRev at your own pace.


![image](https://user-images.githubusercontent.com/16090899/184037594-e56bcfbd-01f4-402f-b884-d93cc2b47604.png)

The GitHub import snap-in enables you to transition from using GitHub issues to managing them in DevRev. After your issues are integrated into DevRev, the GitHub snap-in allows you to receive ongoing GitHub events and harness smart automation.

## How it works

GitHub import provides various options for importing and synchronizing GitHub issues and users. You can import a single repository or as many as needed and choose between a one-time import or a continuous one-way sync.

## Features

**Import**

The basic import allows a one-time transfer of GitHub issues and users from one or multiple repositories.

**Sync to DevRev**

The sync to DevRev enables you to synchronize new items and updates since the last import, ensuring that your DevRev data remains current without the need for frequent manual imports.

## Installation

For detailed installation and configuration instructions, refer to the [GitHub import documentation](https://docs.devrev.ai/integrations/github#issue-import).


GitHub Issues

Import or sync GitHub issues and users for a seamless DevRev onboarding experience.

![image](https://user-images.githubusercontent.com/16090899/195956752-dbcd5f7d-c9c0-4453-ba84-3668d982240c.png)

The Linear import snap-in simplifies moving from Linear issues to issue management in DevRev. It provides multiple methods for importing and synchronizing issues and users from Linear. You can import issues from a single team or as many teams as you need.

## Features

**Import**

The import functionality enables a one-time transfer of Linear issues and user data from a specific team.

**Sync to DevRev**

By using the sync with DevRev functionality, you can re-synchronize a prior import to incorporate any new issues or modifications to previously imported issues from a Linear team.

## Installation

For detailed installation and configuration instructions, refer to the [Linear import documentation](https://devrev.ai/docs/integrations/linear).


Linear

Import or sync Linear issues for a seamless DevRev onboarding experience.

# GitHub Actions

## **Overview**

![image](https://user-images.githubusercontent.com/16090899/184038381-53100232-c5c9-4b33-98db-433f439a65de.png)

Have you ever...

* Configured some GitHub Actions and wished your related work would be updated with these changes?
* Wasted time updating your team on the status of your work?
* Wondered if an issue you worked on was built successfully?

**Don’t sweat it!** This automation will fetch details about different workflows and jobs running in GitHub Actions, and link it to your DevRev issue. Your work is always accounted for and more importantly your team members have visibility and know what you’ve been up to, resulting in fewer interruptions.

## **How it works**

If you are using GitHub Actions to build or carry out workflows, DevRev will track the work related to that workflow and update the timeline of that work item.

## **Features**

**Automatic status updates**

Automatically updates the status of work items related to a job or workflow.

**Record successes and failures**

Record job and workflow results in the work items that triggered them.


GitHub Actions

Track the status of your build, and keep GitHub Actions in sync with your DevRev Issue.

# GitLab for DevRev

Sync GitLab and DevRev so issue status is always real time and driven by code.

## **Overview**

![image](https://raw.githubusercontent.com/shashankcube/image/main/gitlab%20automation.png)

Connect GitLab with DevRev, and ensure your work stays in sync between the two systems, such that issues and statuses are always real-time and driven by code activity. GitLab for DevRev is a snap-in that has been used by several organizations, and ties DevRev issues closely with Git activities, eliminating the need for humans to manage issues.

Why should you un-manage your work? You should use this snap-in if you want to reduce work about work. Let machines manage issues, including creating and updating statuses, so developers can focus on work that matters. You’ll resonate with this, if you have ever:

- Delivered a hot-patch and realized you never had an issue to track it
- Wasted time just updating your team on the status of an issue
- Or just felt that creating and managing issues is a distraction

If your team’s best practice is to link your GitLab activity to an existing issue-ID during branch creation, commits and MRs, then this automation will honor that and enable a GitLab driven issue state, without auto creating issues. We can link your DevRev issue to GitLab activity, through mention of issue-ID in branches, commits, and PRs.

However, if you choose to work in GitLab and never created or linked an issue, you shouldn’t have to sweat it. This automation will automatically create issues that track all associated commits, branches and merge requests. The auto-created issue is enriched with MR description and related GitLab events. The status of these issues is driven by GitLab activity, and the issues will auto-transition stages, from In Development to In Review, and Closed. Your work is always accounted for and more importantly your team members have visibility and know what you’ve been up to, resulting in fewer interruptions.

## **Features**

This automation is powerful, and has several configurable features. As they say, the power is in the defaults! When you install this snap-in, DevRev configures defaults that are tried and tested. You always have the option to customize further.

**Automatic status updates**

You can associate GitLab commits, branches and merge requests with the DevRev issue they correspond to. Doing so allows you to see GitLab activity in the corresponding DevRev issue and to act on those events, allowing you to automate away your manual tasks. Mention DevRev issues in GitLab, and route the relevant GitLab events to this issue. They can be mentioned either as display IDs (ISS-34) or object IDs (issue:34), case insensitively. A DevRev issue can be mentioned in branch names, commit messages, or MR titles.

**Autocreate issues from GitLab branch**

If you do not explicitly associate your DevRev issue to GitLab branches, commits or MRs, then DevRev can autocreate your issues so you have an account of all your GitLab activity. This feature automatically creates an issue when a new branch is created, and tracks all associated commits and merge requests on this issue. The auto-created issues will move status based on Git activity, to in development based on branch and commit activity, and in review when MRs are created and merged. If desired, when MRs are merged, you can personalize the automation to move the issue to closed status. However, this template by default will keep the issue in an open state.

**Autocreate issues from GitLab MRs**

You can choose to automatically create issues when a new MR is created, and it is not linked to an existing DevRev Issue. The behavior is similar to how issues are auto-created with new branches. The auto-created issues will move status based on Git activity, and events are posted on the DevRev issue timeline. If desired, when MRs are merged, you can personalize the automation to move the issue to closed status. However, this automation by default will keep the issue in an open state.

Issues autocreated from GitLab branches or MRs are called "autonomous issues". They have the tag `autonomous`.

**Attribute part to autonomous work**

This automation will infer the part from a repository if possible. If not, the issue is created with a specified default part. You can configure the default part while setting up this snap-in. Every issue on DevRev must have a part attribution.

**Enrich autonomous work descriptions**

Enrich autonomous issues with information derived from GitLab MR events. The title and description of an autocreated issue is enriched with the MR data. When a new GitLab MR is opened or edited, then the related autonomous issue description is updated with the latest MR description. If the user has removed the auto generated text, then the automation will no longer update the description from MRs. Similarly, autonomous work titles are updated with the MR title, if the user hasn’t already updated it.

**Link autonomous work with related issue**

Create a related link between the work-items mentioned in the MR body and the autonomous issues tagged with the branch/MR. When a new GitLab MR is opened/edited, for all the autonomous tagged work items(by branch/MR), automatically mark the issues mentioned in the MR as related.

**Automatically close autonomous work**

Autonomous work gets closed when its related MR is merged. However, if there is no MR activity on this work, then the autonomous work is closed after configurable period.

**Automatic MR tasks**

When a merge request is requested or reopened, a DevRev task is created for you. In order for this automation to be triggerred, you'll need to link your merge requests to DevRev issues. If your MR is removed, merged or closed, then the Task gets deleted. However, if you submit your MR review, then the task is closed.

**Automatic MR reminders**

When a merge request is inactive for more than a specified number of days, then this automation will post a message in all related DevRev issues. You'll need to link your GitLab merge request to DevRev issue to enable these reminders. There are several ways to link your GitLab merge requests to DevRev issues. You can do so by mentioning the DevRev issue ID in the merge request title or body, or mention it in the branch name or commit message. Reminders are also posted for issues created autonomously.


GitLab

Sync GitLab and DevRev so issue status is always real time and driven by code.

# CircleCI for DevRev

Sync DevRev issues with CircleCI and bring visibility into your workflow jobs.

## **Overview**

<img src="https://raw.githubusercontent.com/shashankcube/image/main/circleci.png" align="center"/>

See where your issues are in CI/CD pipeline by bringing in CircleCI events. Improve your processes by making events which need attention visible to everyone in context of the DevRev issue.

## **Features**

This snap-in helps you to keep track of your issue's build progress

**Workflow and Job Updates**

You can associate workflow and job termination events in CircleCI to DevRev issues if the Git branch on which the tests are running is tagged with an issue.

**Decide which events to capture**

Workflow or jobs events can be overwhelming. You can configure if you want only certain events to be populated on the issue's timeline. You can choose between “success”, “failed”, “error”, “canceled”, “unauthorized” events and decide which events the snap-in should listen.

CircleCI

Sync DevRev issues with CircleCI and bring visibility into your workflow jobs.

# AWS Beanstalk

Sync DevRev issues with AWS Beanstalk and bring visibility into your deployments.

## **Overview**

![image](https://user-images.githubusercontent.com/16090899/184038023-b6211d02-e57f-4d45-b701-e69160323102.png)

Users are frequently in the dark about the true status of an issue. Did a commit activity that was made make it to production? Was there a production issue, and if so, was it caused by recent commits? When will it get done? How much work is left? Eliminate these questions in your team sync-ups. Let DevRev snap-ins answer these questions for you. Let the events from disparate systems converge.

The AWS Beanstalk snap-in adds deployment tracking to your DevRev work items. Used in combination with VCS (GitHub, GitLab, Bitbucket) and build snap-ins (CircleCi, GitHub Actions), you can track your work all the way from its commit to its ultimate deployment.

## **Features**

**Automatic status updates**

Automatically updates the status of work items when a related deployment succeeds.

**Record successes and failures**

Record AWS Beanstalk deployment attempts in the work items that triggered them.


AWS Beanstalk

Sync DevRev issues with AWS Beanstalk and bring visibility into your deployments.

# Link preview

The link preview snap-in generates previews of hyperlinks and links to issues, tickets, and parts in real-time, providing you with an overview of the linked content.

## Key Features

* **Automatic preview**: The link preview snap-in eliminates the hassle of manually navigating hyperlinks and referencing issues or tickets. You can view the overview of the link content without navigating to it.

* **Reference context**: The context-rich presentation simplifies discussion related to project management, support, and development by providing details such as title, description, status, owner(s), priority, stage, etc.


Link Preview

Generates previews of hyperlinks and links to issues, tickets, and parts in real-time, providing you with an overview of the linked content.

# Stage Breach Notifier

The stage breach notifier functionality notifies the owner and list of users when a stage of a work item is breached.

## **Features**

* **Stage-specific time-based triggers**:  It enables you to set up stage-specific time thresholds for each work item or ticket stage. This customization allows you to tailor the automation to the specific needs and priorities of different stages in your workflow.
* **Automated notification and communication**: When a work item exceeds the defined time period for a particular stage, automation automatically generates and sends updates to the internal discussion of the work item. This feature ensures that relevant team members are promptly informed of delays or potential issues, facilitating better communication and collaboration.

# How to use stage breach notifier

1. Take the data from the table below and create a CSV file. Make the required changes, such as adding custom stages, adjusting turnaround times for specific subtypes if required and deleting rows where turnaround times do not apply to stages. 
   * For example, if you want to add a custom stage called `uat` for the `Ticket` work item, you can add a row with `Ticket,uat,2` to the CSV file. Similarly, if you do not want to set a turnaround time for the `in_development` stage, you can remove the row with `Ticket,in_development,2` from the CSV file. 
   * If you want to set a different turnaround time for a specific subtype, you can add a row with `work_item,stage_name,turn_around_time,subtype_name` to the CSV file. For example, if you want to set a turnaround time of 3 days for the `work_in_progress` stage for the `Ticket` work item with the `Support` subtype, you can add a row with `Ticket,work_in_progress,3,Support` to the CSV file.
2. In the snap-in **Discussion** tab, enter the `/upload_stage_csv` command.
3. Click the **Upload** button to select the CSV file you created in step 1. After the file is uploaded, the "File uploaded successfully" message is displayed.
4. Reload the page to see the changes in the **Configuration** tab.
5. In the **Configuration** tab, select which users should be notified and click on the **Save** button to save the configuration.

## **CSV file format**
| work_item   | stage_name                 | turn_around_time (days) | subtype                 |
| ----------- | -------------------------- | ----------------------- | ----------------------- |
| Ticket      | queued                     | 2                       |                         |
| Ticket      | work_in_progress           | 2                       |                         |
| Ticket      | awaiting_product_assist    | 2                       |                         |
| Ticket      | awaiting_development       | 2                       |                         |
| Ticket      | in_development             | 2                       |                         |
| Ticket      | awaiting_customer_response | 2                       |                         |
| Issue       | triage                     | 2                       |                         |
| Issue       | backlog                    | 2                       |                         |
| Issue       | prioritized                | 2                       |                         |
| Issue       | in_development             | 2                       |                         |
| Issue       | in_review                  | 2                       |                         |
| Issue       | in_testing                 | 2                       |                         |
| Issue       | in_deployment              | 2                       |                         |
| Opportunity | qualification              | 2                       |                         |
| Opportunity | stalled                    | 2                       |                         |
| Opportunity | validation                 | 2                       |                         |
| Opportunity | negotiation                | 2                       |                         |
| Opportunity | contract                   | 2                       |                         |

Stage Breach Notifier

Timely notification of stage breaches for tickets, issues, and opportunities

The smart sprint snap-in enables you to manage and synchronize sprints and development tasks in agile software development through automation. As a result of this automation, issues are assigned to the appropriate sprints based on their stage and other factors. This results in reduced manual workload and enhanced overall efficiency.

## Features

**Sprint assignment based on stage change**:

- Issues moved to the _in progress_ stage are automatically moved to the active sprint.

- Issues moved to the _prioritized_ stage are automatically moved to the planned sprint.

- Issues moved to the _backlog_ stage are automatically moved to the backlog section.

**Sprint assignments based on parent-child relationships**:

- Incomplete child issues are automatically updated to the same sprint as their parents.


**Sprint assignments based on parts change**:

- If there is a change in the parts of an in progress issue, it is moved to the appropriate active sprint.

- If there is a change in the parts of an issue in the _prioritized_ stage, it is moved to the appropriate planned sprint.

## Installation

For detailed installation and configuration instructions, refer to the [smart sprint documentation](https://docs.devrev.ai/automations/smart-sprint).


Smart Sprint

Automations to manage and synchronize sprints and development tasks to reduce manual updates and improve efficiency.

# Bitbucket for DevRev


## **Overview**

Connect Bitbucket with DevRev for seamless synchronization of work and real-time issue and status updates based on code activity.

The Bitbucket snap-in streamlines DevRev issues with Git actions, removing the need for manual issue management. By automating issue handling, developers can focus on meaningful work rather than administrative tasks. This approach resonates with those who've encountered issues like delivering patches without proper tracking, spending time updating issue statuses or finding issue management distracting.

Linking Bitbucket activity to existing issue IDs during branch creation, commits, and PRs is honored, maintaining a Bitbucket-driven issue state without creating issues automatically. The issues' statuses are guided by Bitbucket activity, transitioning from In Development to In Review and Closed stages. This ensures comprehensive work tracking and enhances team visibility, minimizing disruptions.

## **Features**

The automation is robust, providing a range of customizable features. Upon installation, default configurations will be set up, but you can always tailor them further to suit your preferences.

**Automatic status updates**

Associate your Bitbucket commits, branches, and pull requests with the corresponding DevRev issues and tickets to seamlessly integrate Bitbucket activity into the relevant DevRev issue or ticket. This integration enables you to take action on Bitbucket events within the DevRev issue/ticket, automating manual tasks. Mention DevRev issues or tickets in Bitbucket using either display IDs (e.g., ISS-34) or object IDs (e.g., ticket:34), with case insensitivity. You can include a DevRev issue/ticket reference in branch names, commit messages, or PR titles.


Bitbucket

Sync Bitbucket and DevRev so issue status is always real time and driven by code.


![image](https://github.com/shashankcube/image/blob/main/devrev-converge.png?raw=true)

Supercharge cross-functional work with this set of default automations, propagating information across various entities at DevRev–including conversations, tickets, product enhancements, and development issues.

DevRev's shared system of record opens up doors for the machine to take over and intelligently ensure that heartbeats from various functions of your DevRev workspace travel across each other.

DevRev's system of record converges multiple functions in an organization–touching everything from customer conversations to support tickets to planned product enhancements and then developer issues. Because the system of record is shared, it paves the way for the machine to take on menial, repetitive work, especially around bringing together (or converging) these cross-functional entities (and thus the teams that work on them).

_Convergence with DevRev_ is a set of default automations that powers cross-functional information snap-in in your DevRev workspace, such that updates from product teams' issues and enhancements make their way to tickets in the customer-facing functions and vice versa with little human intervention. Let machines be the messenger of updates so they arrive before the next "Any progress on this?".

## Features

This automation is powerful and has a series of individual, configurable behaviors.

The power is in the defaults! With this pre-enabled snap-in come DevRev's proven defaults. You always have the option to adjust further.

**Automatic customer updates from tickets**

Propagate updates from tickets to related customer conversations so your customer is never in the dark.

- When a ticket is linked to a conversation, autonomously update the conversation and provide a follow-up reference to the customer.
- When a ticket is updated with relevant information, post a notification to the conversation.
- When a ticket is closed, post an autonomous update to any related PLuG conversations.

**Automatic updates between tickets to issues**

Leveraging the association between customer tickets and your product team's issues, this automation focuses on keeping issues aware of changes to tickets and vice-versa so the dev team is kept in the loop.

- When the severity of a ticket changes, autonomously update the issue priority and stage accordingly.
- When progress is made on an issue, update the status on dependent tickets.
- When underlying issues are resolved, advance tickets to the next stage.

**Autonomous issue management**

Parent issues, child issues, dependent issues, and blocked issues are every dev's nightmare. With this set of autonomous convergence behaviors, issues, and their hierarchy become manageable.

- Watch children issues and automatically update a parent issue when a dev starts working on it.
- As children issues make progress, send state updates to parent issues along with information on progress towards completion.
- When parent issues are closed, update child issues automatically.

**Automatic updates between Issues and Enhancements**

Synergizing Parts and work has been made easier by ensuring through automated reminders and suggested actions that your product enhancements and the work items or issues linked to them are always in sync.

- Remind the owners by automatically posting a comment to create and link issues to an enhancement that is ‘In Progress’ state without any linked issue.
- Remind the owners by automatically posting a comment to create and link issues to an enhancement that has been in the ‘Prioritised’ stage for a while.
- Remind the owners through an automatically suggested action to move an open enhancement to ‘In Progress’ when any issue linked to it is moved to the ‘In Progress’.
- Remind the owners by automatically posting a comment to move listed issues out of the triage stage for an enhancement.

**Automatic update between Tickets and Enhancement**

When your customer tickets are linked to an ongoing product enhancement, it is best to provide absolute clarity to the support team on what's happening on the product front through an automatic update system. 

- Automatically subscribe ticket owners to the enhancement that is attached to the ticket so that they stay informed.
- Automatically post comments on tickets whenever the stage is updated in the attached enhancement.

**Automatic resolution and archival of conversations**

When your authenticated customers do not respond to a conversation within a specific period of time set as the resolution timeout, the conversation is automatically marked as resolved. Even though the conversation is resolved, the customer still has the option to reopen it if necessary. However, if the customer does not reply within another specified period of time set as the archival timeout, the conversation is automatically archived and cannot be reopened. The customer can always initiate a new conversation for any follow-up needs.

Please note that these configuration settings only apply to authenticated users. For conversations with guests or visitors, if the customer doesn't respond within 3 days while the conversation is in the _Waiting on user_ stage, it is automatically resolved. After 7 days, it is archived automatically.

## Installation

For detailed installation and configuration instructions, refer to the [Convergence documentation](https://docs.devrev.ai/automations/converge).


Convergence

Real-time updates between customer conversations, support tickets, Product enhancements and developer issues.