tewip-ai 0.9.0 → 0.10.0

package/TEAM-GUIDE.md

@@ -140,6 +140,8 @@ Notes that save you time:
 - `write` never touches your application code. It only adds new test files, and you review and
   commit them yourself.
 - Everything it writes locally goes to the `.tewip` folder in your project.
+- Work items go to **Jira, Rally or GitHub Issues** - set `TEWIP_TRACKER`, or just the credentials
+  of the one you use. GitHub Issues uses your existing `gh` login, so it needs no new secret.
 - Jira works with **Cloud, Server and Data Center**. To read tickets from a tracker anyone can read
   (many open-source ones), `TEWIP_JIRA_URL` alone is enough - no account. Writing needs a token.
 - `tewip jira` shows what it *would* file and creates nothing until you add `--create`. It never

package/dist/engine/work/bug-command.js

@@ -15,8 +15,8 @@ import { importBlobReportDir } from '../import/blob.js';
 import { llmFromEnv } from '../llm/client.js';
 import { buildItems } from '../../outlets/items.js';
 import { ciFacts } from '../ci/platform.js';
-import { Jira, jiraFromEnv, jiraHelp } from './jira.js';
 import { TEWIP_LABEL } from './jira-command.js';
+import { trackerFromEnv, trackerHelp } from './trackers.js';
 /** Bugs Tewip filed carry this as well, so a second run finds them and does not file again. */
 export const BUG_LABEL = 'tewip-bug';
 const isBlobDir = (path) => statSync(path).isDirectory() && readdirSync(path).some((f) => /^report.*\.zip$/.test(f));
@@ -59,11 +59,11 @@ export function bugSummary(item) {
     return (same ? item.title : `${item.title} (${where})`).replace(/\s+/g, ' ').slice(0, 250);
 }
 export async function runBugs(cmd) {
-    const config = jiraFromEnv();
-    // A dry run answers the question people ask first - "what would it file?" - and needs no account
-    // at all. Only --create talks to Jira.
-    if (cmd.create && !config?.token)
-        throw new Error(`filing a bug needs a token: showing what would be filed does not.\n${jiraHelp()}`);
+    // Jira, Rally or GitHub Issues - whichever this team uses. A dry run answers the question people
+    // ask first ("what would it file?") and needs no account at all; only --create writes.
+    const chosen = trackerFromEnv(cmd.projectKey);
+    if (cmd.create && !chosen?.tracker.canWrite())
+        throw new Error(`filing a bug needs a tracker that can be written to; showing what would be filed does not.\n${trackerHelp()}`);
     const path = resolve(cmd.report);
     if (!existsSync(path))
         throw new Error(`no such report: ${cmd.report}`);
@@ -87,41 +87,36 @@ export async function runBugs(cmd) {
         console.log(`${items.length} failure(s), and none of them is a real bug Tewip is confident about (${kinds}). Nothing was filed, which is the point.`);
         return [];
     }
-    const jira = config?.token ? new Jira(config) : null;
-    let type = 'Bug';
+    const tracker = chosen?.tracker.canWrite() ? chosen.tracker : null;
     let existing = [];
-    if (jira) {
-        const types = await jira.issueTypes(cmd.projectKey);
-        type = ['Bug', 'Defect', 'Task'].find((t) => types.includes(t)) ?? types[0];
-        if (!type)
-            throw new Error(`no issue type available in ${cmd.projectKey}`);
-        existing = await jira.findByLabel(cmd.projectKey, BUG_LABEL);
+    if (tracker && chosen) {
+        lines.push(`Tracker: ${tracker.name}`, '');
+        existing = await tracker.mine(chosen.project, BUG_LABEL);
     }
     else {
-        lines.push('Jira was not contacted: this is what would be filed. Set TEWIP_JIRA_URL, TEWIP_JIRA_EMAIL and TEWIP_JIRA_TOKEN, then add --create.', '');
+        lines.push('No tracker was contacted: this is what would be filed. Set one up (see `tewip bugs` without --create for the settings), then add --create.', '');
     }
     let filed = 0;
     for (const item of bugs.slice(0, cmd.max)) {
         const summary = bugSummary(item);
-        const already = existing.find((i) => i.summary === summary);
+        const already = existing.find((i) => i.title === summary);
         if (already) {
             lines.push(`  ${item.title}  already filed as ${already.key}`);
-            if (cmd.create && jira) {
-                await jira.comment(already.key, seenAgain(item, facts.runUrl)).catch(() => lines.push(`    (could not add the note to ${already.key})`));
+            if (cmd.create && tracker) {
+                await tracker.comment(already.key, seenAgain(item, facts.runUrl)).catch(() => lines.push(`    (could not add the note to ${already.key})`));
                 lines.push(`    added a note that it happened again`);
             }
             continue;
         }
-        if (!cmd.create || !jira) {
+        if (!cmd.create || !tracker || !chosen) {
             lines.push(`  would file: ${summary}`);
             lines.push(`      because: ${item.diagnosis.category} at ${item.diagnosis.confidence.toFixed(2)} - ${item.errorHead.replace(/\s+/g, ' ').slice(0, 100)}`);
             continue;
         }
-        const key = await jira.createIssue({
-            projectKey: cmd.projectKey,
-            type,
-            summary,
-            description: bugBody(item, facts.runUrl),
+        const key = await tracker.create(chosen.project, {
+            kind: 'bug',
+            title: summary,
+            body: bugBody(item, facts.runUrl),
             labels: [TEWIP_LABEL, BUG_LABEL, `tewip-${item.component.replace(/[^\w-]+/g, '-')}`.slice(0, 40)],
         });
         lines.push(`  filed ${key}: ${summary}`);
@@ -129,7 +124,7 @@ export async function runBugs(cmd) {
     }
     const left = items.length - bugs.length;
     lines.push('', `${bugs.length} of ${items.length} failure(s) look like real bugs; ${left} were flaky tests, environment or test data and were deliberately not filed.`);
-    lines.push(cmd.create ? `${filed} ticket(s) created. Tewip never moves, assigns or closes one.` : 'Nothing was created. Add --create to file them.');
+    lines.push(cmd.create ? `${filed} ticket(s) created in ${tracker?.name}. Tewip never moves, assigns or closes one.` : 'Nothing was created. Add --create to file them.');
     console.log(lines.join('\n'));
     return bugs;
 }

package/dist/engine/work/github-issues.js

@@ -0,0 +1,63 @@
+// GitHub Issues, for the many teams whose backlog is simply their repository.
+//
+// It uses the token in the environment, or the `gh` CLI login the person already has, so a team on
+// GitHub needs no new account and no new secret. The restraint is the same: create, comment on what
+// it created, find what it filed before by its label. It never closes an issue, never assigns
+// anyone, and never touches an issue somebody else opened.
+import { spawnSync } from 'node:child_process';
+export function githubIssuesFromEnv(env = process.env) {
+    const repo = (env.TEWIP_GITHUB_REPO ?? env.GITHUB_REPOSITORY ?? '').trim();
+    if (!repo)
+        return null;
+    return { repo, token: (env.TEWIP_GITHUB_TOKEN ?? env.GITHUB_TOKEN ?? env.GH_TOKEN ?? '').trim() || ghCliToken() };
+}
+/** The token the `gh` CLI already holds, so a person logged in there needs nothing else. */
+function ghCliToken() {
+    const r = spawnSync('gh auth token', { shell: true, encoding: 'utf8', timeout: 20_000 });
+    return r.status === 0 ? (r.stdout ?? '').trim() : '';
+}
+/** The kind of work is a label here: GitHub has one issue type and many labels. */
+const KIND_LABEL = { 'test-case': 'test-case', bug: 'bug', story: 'story', epic: 'epic' };
+export class GitHubIssues {
+    name = 'GitHub Issues';
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    canWrite() {
+        return Boolean(this.config.repo && this.config.token);
+    }
+    async request(method, path, body) {
+        const res = await fetch(`https://api.github.com${path}`, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.config.token}`,
+                Accept: 'application/vnd.github+json',
+                'X-GitHub-Api-Version': '2022-11-28',
+                'User-Agent': 'tewip',
+                ...(body ? { 'Content-Type': 'application/json' } : {}),
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok)
+            throw new Error(`GitHub ${method} ${path} -> ${res.status}: ${(await res.text()).slice(0, 300)}`);
+        return (res.status === 204 ? undefined : await res.json());
+    }
+    async mine(_project, label) {
+        // Closed ones count too: an issue Tewip filed and a person closed must not be filed again.
+        const issues = await this.request('GET', `/repos/${this.config.repo}/issues?labels=${encodeURIComponent(label)}&state=all&per_page=100`);
+        return issues.map((i) => ({ key: `#${i.number}`, title: i.title, url: i.html_url }));
+    }
+    async create(_project, item) {
+        const created = await this.request('POST', `/repos/${this.config.repo}/issues`, {
+            title: item.title.slice(0, 250),
+            body: item.body.slice(0, 60_000),
+            labels: [...new Set([...(item.labels ?? []), KIND_LABEL[item.kind], ...(item.priority ? [`priority:${item.priority.toLowerCase()}`] : [])])],
+        });
+        return `#${created.number}`;
+    }
+    async comment(key, text) {
+        const number = key.replace('#', '');
+        await this.request('POST', `/repos/${this.config.repo}/issues/${number}/comments`, { body: text.slice(0, 60_000) });
+    }
+}

package/dist/engine/work/rally.js

@@ -0,0 +1,84 @@
+import { priorityWord } from './tracker.js';
+/** Rally's own name for each kind of item, and the endpoint that creates it. */
+const TYPE = {
+    'test-case': 'testcase',
+    bug: 'defect',
+    story: 'hierarchicalrequirement',
+    epic: 'portfolioitem/feature',
+};
+/** The field that holds the words, which differs by type. */
+const BODY_FIELD = { 'test-case': 'Description', bug: 'Description', story: 'Description', epic: 'Description' };
+export function rallyFromEnv(env = process.env) {
+    const apiKey = env.TEWIP_RALLY_KEY?.trim();
+    if (!apiKey)
+        return null;
+    return {
+        baseUrl: (env.TEWIP_RALLY_URL ?? 'https://rally1.rallydev.com').trim().replace(/\/+$/, ''),
+        apiKey,
+        project: (env.TEWIP_RALLY_PROJECT ?? '').trim(),
+    };
+}
+export class Rally {
+    name = 'Rally';
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    canWrite() {
+        return Boolean(this.config.apiKey && this.config.project);
+    }
+    async request(method, path, body) {
+        const res = await fetch(`${this.config.baseUrl}/slm/webservice/v2.0${path}`, {
+            method,
+            headers: { ZSESSIONID: this.config.apiKey, Accept: 'application/json', ...(body ? { 'Content-Type': 'application/json' } : {}) },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok)
+            throw new Error(`Rally ${method} ${path} -> ${res.status}: ${(await res.text()).slice(0, 300)}`);
+        const json = (await res.json());
+        // Rally answers 200 with the errors inside the body, so they have to be read out of it.
+        const errors = json?.CreateResult?.Errors ?? json?.QueryResult?.Errors ?? json?.OperationResult?.Errors ?? [];
+        if (errors.length > 0)
+            throw new Error(`Rally ${method} ${path}: ${errors.join('; ').slice(0, 300)}`);
+        return json;
+    }
+    /** Items Tewip filed before, found by the tag it puts on everything it creates. */
+    async mine(project, label) {
+        const found = [];
+        for (const kind of ['testcase', 'defect', 'hierarchicalrequirement']) {
+            const query = encodeURIComponent(`(Tags.Name = "${label}")`);
+            const scope = project || this.config.project;
+            const path = `/${kind}?query=${query}&fetch=FormattedID,Name&pagesize=200${scope ? `&project=${encodeURIComponent(scope)}` : ''}`;
+            try {
+                const body = await this.request('GET', path);
+                for (const r of body.QueryResult?.Results ?? [])
+                    found.push({ key: String(r.FormattedID ?? r._ref ?? ''), title: String(r.Name ?? ''), url: r._ref });
+            }
+            catch {
+                // A workspace without that type is normal; the others still answer.
+            }
+        }
+        return found;
+    }
+    async create(project, item) {
+        const type = TYPE[item.kind];
+        const fields = {
+            Name: item.title.slice(0, 250),
+            [BODY_FIELD[item.kind]]: item.body.slice(0, 32_000),
+            Project: project || this.config.project,
+        };
+        if (item.priority)
+            fields[item.kind === 'bug' ? 'Priority' : 'Risk'] = priorityWord('rally', item.priority);
+        if (item.parent)
+            fields[item.kind === 'story' ? 'PortfolioItem' : 'WorkProduct'] = item.parent;
+        const key = type.split('/')[0];
+        const created = await this.request('POST', `/${type}/create`, { [capitalise(key)]: fields });
+        const made = created.CreateResult?.Object;
+        return String(made?.FormattedID ?? made?._ref ?? '');
+    }
+    /** A note on an item Tewip created. Rally calls it a ConversationPost. */
+    async comment(key, text) {
+        await this.request('POST', '/conversationpost/create', { ConversationPost: { Artifact: key, Text: text.slice(0, 4000) } });
+    }
+}
+const capitalise = (word) => word.charAt(0).toUpperCase() + word.slice(1);

package/dist/engine/work/tracker.js

@@ -0,0 +1,37 @@
+export const TEWIP_LABEL = 'tewip';
+/** Every tracker's own word for a priority, so a P0 does not arrive as "P0" in a tool that says "High". */
+export const PRIORITY_WORDS = {
+    jira: { P0: 'Highest', P1: 'High', P2: 'Medium' },
+    rally: { P0: 'Resolve Immediately', P1: 'High Attention', P2: 'Normal' },
+    github: { P0: 'priority:high', P1: 'priority:medium', P2: 'priority:low' },
+};
+export function priorityWord(tracker, priority) {
+    return PRIORITY_WORDS[tracker]?.[priority] ?? priority;
+}
+/** Which tracker the settings point at. Jira stays the default, because most teams are there. */
+export function trackerNameFromEnv(env = process.env) {
+    const named = (env.TEWIP_TRACKER ?? '').trim().toLowerCase();
+    if (named === 'rally' || named === 'github' || named === 'jira')
+        return named;
+    if (env.TEWIP_RALLY_KEY)
+        return 'rally';
+    if (env.TEWIP_GITHUB_REPO && !env.TEWIP_JIRA_URL)
+        return 'github';
+    return 'jira';
+}
+export function trackerHelp() {
+    return [
+        'No tracker is set up. Tewip files work items into whichever of these you use:',
+        '',
+        '  Jira (Cloud, Server or Data Center)',
+        '    TEWIP_JIRA_URL=https://your-team.atlassian.net   TEWIP_JIRA_EMAIL=you@company.com   TEWIP_JIRA_TOKEN=...',
+        '',
+        '  Rally (Broadcom, formerly CA Agile Central)',
+        '    TEWIP_RALLY_KEY=_abc123...   TEWIP_RALLY_PROJECT=/project/12345   (TEWIP_RALLY_URL for on-premise)',
+        '',
+        '  GitHub Issues',
+        '    TEWIP_GITHUB_REPO=owner/name   TEWIP_GITHUB_TOKEN=ghp_...  (or be logged in with the gh CLI)',
+        '',
+        'Set TEWIP_TRACKER=jira|rally|github when more than one is configured.',
+    ].join('\n');
+}

package/dist/engine/work/trackers.js

@@ -0,0 +1,72 @@
+// Picking the tracker a team actually uses, and making Jira look like the others.
+//
+// Everything above this line in Tewip talks to `Tracker`, so adding Linear or Azure Boards later is
+// one file and no changes anywhere else - and the promises (create, never move, never assign, never
+// close, never file twice) hold for all of them by construction.
+import { Jira, jiraFromEnv } from './jira.js';
+import { Rally, rallyFromEnv } from './rally.js';
+import { GitHubIssues, githubIssuesFromEnv } from './github-issues.js';
+import { priorityWord, trackerHelp, trackerNameFromEnv } from './tracker.js';
+/** Jira, wearing the same interface as the rest. */
+export class JiraTracker {
+    name = 'Jira';
+    jira;
+    hasToken;
+    /** Issue types this project really has, read once. */
+    types = null;
+    constructor(jira, hasToken) {
+        this.jira = jira;
+        this.hasToken = hasToken;
+    }
+    canWrite() {
+        return this.hasToken;
+    }
+    async mine(project, label) {
+        return (await this.jira.findByLabel(project, label)).map((i) => ({ key: i.key, title: i.summary }));
+    }
+    /** Jira projects differ in which types exist, so the nearest one that does is used. */
+    async typeFor(project, kind) {
+        this.types ??= await this.jira.issueTypes(project);
+        const wanted = {
+            'test-case': ['Test', 'Test Case', 'Task'],
+            bug: ['Bug', 'Defect', 'Task'],
+            story: ['Story', 'User Story', 'Task'],
+            epic: ['Epic', 'Feature', 'Task'],
+        };
+        const found = wanted[kind].find((t) => this.types.includes(t)) ?? this.types[0];
+        if (!found)
+            throw new Error(`no issue type available in ${project}`);
+        return found;
+    }
+    async create(project, item) {
+        return this.jira.createIssue({
+            projectKey: project,
+            type: await this.typeFor(project, item.kind),
+            summary: item.title,
+            description: item.body,
+            labels: item.labels,
+            parentKey: item.parent,
+        });
+    }
+    async comment(key, text) {
+        await this.jira.comment(key, text);
+    }
+}
+/**
+ * The tracker the settings point at, or null when none is configured. A tracker that can only be
+ * read (a public Jira, or GitHub without a token) still comes back: a dry run needs no write.
+ */
+export function trackerFromEnv(projectKey = '', env = process.env) {
+    const id = trackerNameFromEnv(env);
+    if (id === 'rally') {
+        const config = rallyFromEnv(env);
+        return config ? { tracker: new Rally(config), project: projectKey || config.project, id } : null;
+    }
+    if (id === 'github') {
+        const config = githubIssuesFromEnv(env);
+        return config ? { tracker: new GitHubIssues(config), project: projectKey || config.repo, id } : null;
+    }
+    const config = jiraFromEnv();
+    return config ? { tracker: new JiraTracker(new Jira(config), Boolean(config.token)), project: projectKey, id } : null;
+}
+export { priorityWord, trackerHelp };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tewip-ai",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Tewip finds why each failing test failed - real bug, flaky test, environment, test data or changed selector - for any stack, from the command line, CI, or your editor.",
   "keywords": [
     "test-failures",