WITTA

Who Is The Team Authority

Who exactly knows the person best to advise on tasks and coding problems?
The person who has committed the code, that's who!
The person who helps in confluence chats, that's who!
The person who checks in the change, that's who!

Using AI analysis we create a trained model of the code base and ask it.

Introduction

https://developer.atlassian.com/ hack2020
https://www.atlassian.com/forge
https://codegeist2020.slack.com/

https://witta.atlassian.net

Inspiration

I am an avid consumer of personal assistants, ranging from "Alexa turn off the light/heater" to "OK Google, do I have anything on tomorrow". These seem to be cute skills, but not particularly time saving in the long term.

As a seasoned (more pepper than salt) developer, and freelancer I often struggle with the small spheres of knowledge which some teams and companies operate in. With everyone being busy, or not knowing who did what and who the current authority on a subject is. I eventually find out, but usually via several hours of other peoples precious time. I've always wanted a service which volunteered this information while I was developing tasks or documentation and to be able to contact the very person who could answer my questions quickly and with Authority.

Most of our time is spent searching for information, and to create an AI driven expert for locating the authority on a codebase or subject within the company would save a lot of my time.

Eventually, I see WITTA transforming into a codebase assistant, being able to ask questions like "Who has committed the most database code in this project" and "Who knows most about widgets". These are very generalised questions, but I don't think we're that far from being able to create something a few steps closer.

Aims

When working on a task, or gathering information, the person who is commonly believed to have the most knowledge may not actually be the correct person to contact. Or the process to find the people to speak with is fraught with red tape and assumptions.

All we want to know is;

  1. Who is the best for this task?
    • Submit task text (unfiltered)
    • identify user with git experience, etc
  2. Are they free?
    • system allows organised meeting time
  3. Can we ask a question of them?

Instead of direct contact, authorities can be contacted without the team knowing who, via the WITTA system, and are invited to contribute. No pressure.
e.g. "This JIRA ticket has been created and the author may need your expertise. The creator has asked for optional feedback."

Alternatively, list of people are generated under jira ticket with specific knowledge

  1. recently committed code in area of current task
  2. have commits which mention keywords mentioned in task
  3. have approved code in area of current task
  4. have created tickets in area of current task.

Also, while in IDE, show people who are most proficient in the particular area by accessing the WITTA Api.

AI Aims

To index a whole company's JIRA and Confluence stack may be a step too far, so there may need to be individual stacks of knowledge to enable the AI engine to focus on specific projects and collections only.

Text Analysis ; Person has created content for target / key phrase
Code Analysis ; Person has submitted code/approved code in code area
Comment Analysis ; Person has commented on code area/confluence Sentiment Analysis; To determine areas of the codebase which have caused issues in the past

UI Elements

Jira panel : See experts relevant to this JIRA
Confluence Panel : See experts relevant to this JIRA

Services available for future WITTA forge integration

Webservice 1: WITTA query service to interrogate the AI model remotely Webtrigger: Submit new content to the AI model

UI: Submit tickets or Confluence pages to be consumed by the Witta engine. Request Adepts from WITTA

Ingestion

The way which the information will be ingested and tested will depend on the technology used and the weight of authority in each organisation. For example, an organisation may put more weight on code comments than confluence comments. Others may only wish the knowledge model to be purely code based, another, comment based.

Phrases and content will be separated into code and system models. Where code will focus on comments made in submissions to bitbucket and diffs within codebases, and system will focus on confluence and JIRA comments, reinforced with emoji and like detection.

Ingestion of current content

It should be possible to write a script that will start at the first commit, or confluence message related to a task, and find references to JIRA and Confluence and commits in BitBucket and submit them for ingestion.

Model Training

Where ingestion would allow the models to be populated, it will need to be trained prior to the dataset being utilised.

Future considerations / possibilities

The model itself would need to be retrained periodically as the data set grows to ensure that the quality of suggestions remain high.
The interface for this will need to be created as per the AI platform used, but is wholly separate from WITTA development.

As the model increases in size, the predictions may also include showing similar tasks and completed code, and ultimately suggesting solutions to tasks and what areas caused repeated commits and longer than estimated task durations.

Implemented Features

Two Lambda functions were created.
Two AWS API interfaces were created.
Two Forge UI components created

  • WITTA Panel, showing authorities based on contents of a task in JIRA
  • WITTA Ingest, automatically supplying content to AI engine
  • WITTA Query, showing authorities based on selected text in Confluence

Resources

Education Pack

Icons made by Nhor Phai from www.flaticon.com

Appendix / code examples

AWS Event

WITTA-Update arn:aws:lambda:us-east-2:652680035346:function:witta-update https://mzh822kz64.execute-api.us-east-2.amazonaws.com/default/witta-update

WITTA Update API

    API: api-gateway/mzh822kz64/*/*/witta-update
    API endpoint: https://mzh822kz64.execute-api.us-east-2.amazonaws.com/default/witta-update
    API key: 
    API name: witta-update-API
    API type: rest
    Authorization: NONE
    Enable metrics and error logging: No
    Method: ANY
    Resource path: /witta-update
    Security: NONE_KEY
    Stage: default
exports.handler = async (event) => {
    const uuid = {
        v1:()=>{
            return '00001'
        }

    }

    let resp=[];

    let date='2001-01-01';
    let guid=uuid.v1();
    let teamId=event['teamid'];
    let projectId=event['projectid'];
    let siteId=event['siteid'];
    let userId=event['userid'];
    let c=0;
    let t=event['data'].length;
    const processData=(data)=>{
        //upload to witta-engine ML 
        c++;
        resp.push(guid+':'+siteId+'-'+projectId+'-'+teamId+'-'+userId+' data item '+c+' of '+t+' from '+data['source']+'(REF:'+data['ref']+') ingested');
    }

    resp.push('WITTA-UPDATE');
    event['data'].forEach(d=>processData(d));
    resp.push(guid+':'+date+': All ('+c+') Items of Data Processed, thankyou');
    const response = {
        statusCode: 200,
        body: JSON.stringify(resp),
    };
    return response;
};
WITTAUpdate
{
  "data": [
    {
      "ref": "reference-1",
      "source": "jira",
      "text": "some text here"
    },
    {
      "ref": "reference-2",
      "source": "confluence",
      "text": "some text here"
    }
  ],
  "userid": "person1",
  "teamid": "team-gamma",
  "projectid": "project-alpha",
  "siteid": "site-beta"
}
WITTA-Find
arn:aws:lambda:us-east-2:652680035346:function:WITTA-Find
https://agtnwb4k4i.execute-api.us-east-2.amazonaws.com/default/WITTA-Find
exports.handler = async (event) => {
    let content=event['content-by-importance'];
    let people=['5f03a0bf1a26ad0014e8bfe6','5efe82df3404690bae97dd5c','5f03a0bf1a26ad0014e8bfe6','5f03a0c0502ce1001dc740ae','5f03a0bf502ce1001dc740ab']

    const PopulateResponse=(query)=>{
        //This would call the WITTA ML algorithms, populated by WITTA-Update
        let selected=[];
        let num=Math.floor(Math.random()*people.length);
        let highest=0;
        let total=0;
        for(var i=0;i<num;i++){
            let person=people[Math.floor(Math.random()*people.length)];
            let score=Math.random();
            selected.push({"userref":person,"score":score});
            if(highest<score){highest=score;}
            total=total+score;
        }
        let average=total/num;
        return {'query':event['query'],"numadepts":num,"maxscore":highest,"averagescore":average,"adepts":selected};
    }

    let resp=PopulateResponse(event['query'])
    const response = {
        statusCode: 200,
        body: JSON.stringify(resp),
    };
    return response;
};
{
  "query": "some query hered"
}
WITTA-Find API

    API: api-gateway/agtnwb4k4i/*/*/WITTA-Find
    API endpoint: https://agtnwb4k4i.execute-api.us-east-2.amazonaws.com/default/WITTA-Find
    API key: 
    API name: witta-find-API
    API type: rest
    Authorization: NONE
    Enable metrics and error logging: No
    Method: ANY
    Resource path: /WITTA-Find
    Security: NONE_KEY
    Stage: default
Share this project:

Updates