Jira + Slack Integration: Team Workflows

const agent = new AgentCorex({
  apiKey: process.env.AGENT_COREX_API_KEY
});

async function onJiraIssueUpdated(issue) {
  const tools = await agent.retrieveTools({
    query: "Notify Slack channel about Jira issue update"
  });

  const message = formatIssueUpdate(issue);

  await agent.executeTool({
    toolName: 'send-slack-message',
    params: {
      channel: `#${issue.project.toLowerCase()}`,
      message: message,
      blocks: [
        {
          type: "section",
          text: {
            type: "mrkdwn",
            text: `*${issue.key}: ${issue.summary}*\n${issue.description}`
          }
        },
        {
          type: "section",
          fields: [
            {
              type: "mrkdwn",
              text: `*Status*\n${issue.status.name}`
            },
            {
              type: "mrkdwn",
              text: `*Assignee*\n${issue.assignee.displayName}`
            }
          ]
        }
      ]
    }
  });
}

app.message(async ({ message, client }) => {
  if (!message.text.includes('@create-issue')) return;

  const tools = await agent.retrieveTools({
    query: "Create Jira issue from Slack message"
  });

  const jiraIssue = await agent.executeTool({
    toolName: 'create-jira-issue',
    params: {
      project: 'FEATURES',
      title: message.text.replace('@create-issue', '').trim(),
      description: `Created from Slack message by ${message.user}`,
      priority: 'Medium'
    }
  });

  await client.reactions.add({
    channel: message.channel,
    timestamp: message.ts,
    emoji: 'jira'
  });

  await client.chat.postMessage({
    channel: message.channel,
    text: `Created Jira issue ${jiraIssue.key}`
  });
});

async function postSprintStatus() {
  const tools = await agent.retrieveTools({
    query: "Get Jira sprint status and summarize for Slack"
  });

  // Get sprint info
  const sprint = await agent.executeTool({
    toolName: 'get-current-sprint',
    params: {
      board: 'PLATFORM'
    }
  });

  // Get issues
  const issues = await agent.executeTool({
    toolName: 'list-sprint-issues',
    params: {
      sprintId: sprint.id
    }
  });

  // Summarize
  const summary = summarizeSprintStatus(issues);

  // Post to Slack
  await agent.executeTool({
    toolName: 'send-slack-message',
    params: {
      channel: '#standup',
      message: summary
    }
  });
}

// Run daily at 10am
schedule.scheduleJob('0 10 * * 1-5', postSprintStatus);

async function autoAssignIssue(issue) {
  const tools = await agent.retrieveTools({
    query: "Assign Jira issue to team and notify Slack"
  });

  // Determine team from labels
  const team = determineTeamFromLabels(issue.labels);

  // Get team members
  const members = await agent.executeTool({
    toolName: 'list-slack-channel-members',
    params: {
      channel: `#team-${team}`
    }
  });

  // Find available team lead
  const assignee = findAvailableTeamMember(members);

  // Assign in Jira
  await agent.executeTool({
    toolName: 'assign-jira-issue',
    params: {
      issueKey: issue.key,
      assignee: assignee.email
    }
  });

  // Notify in Slack
  await agent.executeTool({
    toolName: 'send-slack-dm',
    params: {
      user: assignee.slackId,
      message: `New issue assigned: ${issue.key} - ${issue.summary}`
    }
  });
}

async function escalateCriticalIssue(issue) {
  if (issue.priority !== 'Critical') return;

  const tools = await agent.retrieveTools({
    query: "Notify incident team of critical Jira issue via Slack"
  });

  // Get all developers
  const devTeam = await agent.executeTool({
    toolName: 'list-slack-channel-members',
    params: {
      channel: '#incidents'
    }
  });

  // Create mentions
  const mentions = devTeam.members.map(m => `<@${m.id}>`).join(' ');

  // Post escalation
  await agent.executeTool({
    toolName: 'send-slack-message',
    params: {
      channel: '#incidents',
      message: `🚨 CRITICAL ISSUE: ${issue.key}`,
      blocks: [
        {
          type: "section",
          text: {
            type: "mrkdwn",
            text: `${mentions}\n\n*CRITICAL:* ${issue.summary}\n${issue.description}`
          }
        },
        {
          type: "actions",
          elements: [
            {
              type: "button",
              text: { type: "plain_text", text: "View in Jira" },
              url: issue.url
            },
            {
              type: "button",
              text: { type: "plain_text", text: "I'll Handle It" },
              action_id: "take_issue"
            }
          ]
        }
      ]
    }
  });
}

1. Slack Request
   User: "We need dark mode"
   ↓

2. Create Jira Issue
   Agent creates: FEATURES-123
   ↓

3. Assign to Team
   Assigned to: @backend-team
   Slack notification sent
   ↓

4. Development in Progress
   Dev updates Jira status
   Slack channel auto-updates
   ↓

5. Code Review
   PR created in GitHub
   Jira linked to PR
   Slack notified
   ↓

6. Deployment
   Issue marked done
   Slack celebrates! 🎉
   ↓

7. Close in Jira
   Jira status: Done
   Slack archives thread