engineering-memory 1.11.29 → 1.11.31

package/runtime/dist/src/mcp/review-tools.js

@@ -39,6 +39,7 @@ const reviewRead = z.object({
     delivery: z.object({
         externalTaskId: z.string(),
         reviewState: z.string().nullish(),
+        reviewReopenReason: z.string().nullish(),
         reviewPolicy: z.string().optional(),
     }),
     rounds: z.array(z.object({ id: z.string(), state: z.string() })),
@@ -132,7 +133,7 @@ export function registerReviewTools(server, service) {
         inputSchema: z.strictObject({ projectId: z.string().uuid(), taskId: z.string().uuid() }),
     }, async (input) => output(await service.reviewGet(input)));
     server.registerTool('review.start', {
-        description: "Start the next code review round of a delivered task, or return the round already open at the same commit, from a clone of the task's project on this computer. It fetches the pushed branch and its target from origin without checking anything out and returns the review packet: the commits to compare, the changed files, the records that governed the change, earlier findings and the read-only Git commands the reviewer may use. Pass targetBranch only when the delivery names no target branch.",
+        description: "Start the next code review round of a delivered task, or return the round already open at the same commit, from a clone of the task's project on this computer. It fetches the pushed branch and its target from origin without checking anything out and returns the review packet: the commits to compare, the changed files, the records that governed the change, earlier findings and the read-only Git commands the reviewer may use; from the second round on, also what changed since the previous round. The target branch is the one recorded for its PR/MR, else the one the delivery answer named; pass targetBranch only when neither is right.",
         inputSchema: z.strictObject({
             projectId: z.string().uuid(),
             taskId: z.string().uuid(),
@@ -150,7 +151,7 @@ export function registerReviewTools(server, service) {
         }),
     }, async (input) => output(await service.reviewRules(input)));
     server.registerTool('review.submit', {
-        description: 'Record the result of a review round: its findings, or an empty list when there are none. E-mail addresses, IP addresses and user folders in descriptions are masked first; a description that still holds a secret or personal data is refused so it can be rephrased. Sending the same result again changes nothing.',
+        description: 'Record the result of a review round: its findings, or an empty list when there are none. E-mail addresses, IP addresses and user folders in descriptions are masked first; a description that still holds a secret or personal data is refused so it can be rephrased. Sending the same result again changes nothing. The findings, and later the conclusion, are written on the PR/MR as a comment: on GitLab with the token the user saved on this computer, elsewhere comment.body is returned for you to post.',
         inputSchema: z.strictObject({
             projectId: z.string().uuid(),
             roundId: z.string().uuid(),
@@ -285,6 +286,8 @@ export function registerReviewTools(server, service) {
             });
         if (!waitingReview.includes(state ?? ''))
             return refusal(`The review of ${task} is ${state ?? 'not tracked'}, so there is nothing to end. review.get shows where it stands.`, 'review.get');
+        if (input.outcome === 'passed' && review.delivery.reviewReopenReason)
+            return refusal(`The review of ${task} had passed, then its PR/MR got ${review.delivery.reviewReopenReason === 'new_target' ? 'a new target branch' : 'a new commit'}, so it passes again only after a round reviews it. Start one with review.start, or ask the user whether to skip or exempt it.`, 'review.start');
         if (input.outcome === 'passed' &&
             (state !== 'pending' ||
                 !review.rounds.some((round) => round.state === 'submitted') ||
@@ -353,7 +356,7 @@ export function registerReviewTools(server, service) {
         });
     });
     server.registerTool('review.make_ready', {
-        description: "Make the PR/MR of a delivered task ready for the team once its code review ended, or, when the user asks, one that has no code review; while a review runs it refuses. On GitLab with the user's own token saved on this computer, it removes Draft from the merge request and records it; anywhere else it says exactly what to do, since the draft is marked ready with the provider's own tools or by the user.",
+        description: "Make the PR/MR of a delivered task ready for the team once its code review ended, or, when the user asks, one that has no code review; while a review runs it refuses. On GitLab with the user's own token saved on this computer, it writes the review conclusion as a comment when it is not written yet, removes Draft from the merge request and records it; anywhere else it says exactly what to do, since the draft is marked ready with the provider's own tools or by the user.",
         inputSchema: z.strictObject({ projectId: z.string().uuid(), taskId: z.string().uuid() }),
     }, async (input) => output(await service.reviewMakeReady(input)));
 }

package/runtime/dist/src/mcp/tool-annotations.js

@@ -140,6 +140,12 @@ export const toolAnnotations = {
     'live_status.list': read,
     'live_status.notice_presented': repeatableWrite,
     'live_status.set_sharing': write,
+    'jira.status': read,
+    'jira.connect': outward, // the user approves access on Atlassian through the link it returns
+    'jira.disconnect': destructive, // the stored access is deleted; only a new approval restores it
+    'jira.link_project': write,
+    'jira.unlink_project': write,
+    'jira.map_people': write,
     'auth.status': read,
     'auth.signin_browser': outward,
     'auth.logout': destructive,

package/runtime/dist/src/mcp/tool-definitions.js

@@ -1,6 +1,7 @@
 import { registerDeliveryTools } from './delivery-tools.js';
 import { registerReviewTools } from './review-tools.js';
 import { registerLiveStatusTools } from './live-status-tools.js';
+import { registerJiraTools } from './jira-tools.js';
 import { registerStatusMeaningTools } from './status-meaning-tools.js';
 import { registerStatusRemapTools } from './status-remap-tools.js';
 import { registerWorkflowTools } from './workflow-tools.js';
@@ -180,6 +181,12 @@ export const engineeringMemoryToolNames = [
     'live_status.list',
     'live_status.notice_presented',
     'live_status.set_sharing',
+    'jira.status',
+    'jira.connect',
+    'jira.disconnect',
+    'jira.link_project',
+    'jira.unlink_project',
+    'jira.map_people',
     'auth.status',
     'auth.signin_browser',
     'auth.logout',
@@ -1252,6 +1259,7 @@ export function registerEngineeringMemoryTools(server, service) {
         inputSchema: z.object({ projectId: z.string().min(1) }),
     }, async (input) => toolResult(await service.projectLinks(input)));
     registerLiveStatusTools(server, service);
+    registerJiraTools(server, service);
     server.registerTool('auth.status', {
         description: 'Check whether OS credential storage contains an active local Engineering Memory session.',
         inputSchema: z.object({}),

package/runtime/dist/src/providers/gitlab.js

@@ -152,6 +152,7 @@ export const mergeRequestSchema = z.object({
     project_id: z.number().optional(),
     source_project_id: z.number().optional(),
 });
+const noteSchema = z.object({ id: z.number(), body: z.string() });
 export function reviewState(request) {
     if (request.state === 'merged')
         return 'merged';
@@ -227,6 +228,13 @@ export class GitLabClient {
             ...(request.description ? { description: request.description } : {}),
         }));
     }
+    async notes(address, token, project, number) {
+        const query = new URLSearchParams({ sort: 'desc', order_by: 'created_at', per_page: '100' });
+        return this.shape(address, z.array(noteSchema), await this.call(address, token, 'GET', `/projects/${encodeURIComponent(project)}/merge_requests/${number}/notes?${query}`));
+    }
+    async createNote(address, token, project, number, body) {
+        this.shape(address, noteSchema, await this.call(address, token, 'POST', `/projects/${encodeURIComponent(project)}/merge_requests/${number}/notes`, { body }));
+    }
     async retitleMergeRequest(address, token, project, number, title) {
         return this.shape(address, mergeRequestSchema, await this.call(address, token, 'PUT', `/projects/${encodeURIComponent(project)}/merge_requests/${number}`, { title }));
     }

package/runtime/dist/src/providers/jira-connect.js

@@ -0,0 +1,182 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import * as z from 'zod/v4';
+import { endpoints } from '../config.js';
+import { ApiResponseError } from '../runtime/api-client.js';
+import { copies, escapeHtml, format, textDirection } from '../runtime/texts.js';
+const text = z.string().min(1);
+const pageWording = z.strictObject({
+    title: text,
+    connected: text,
+    chooseSite: text,
+    cancelled: text,
+    failed: text,
+    invalid: text,
+});
+const started = z.object({
+    requestId: z.uuid(),
+    connectUrl: z.url(),
+    expiresAt: z.iso.datetime({ offset: true }),
+});
+export class JiraConnectCoordinator {
+    client;
+    language;
+    flows = new Map();
+    constructor(client, language = async () => undefined) {
+        this.client = client;
+        this.language = language;
+    }
+    state(organizationId) {
+        return this.flows.get(organizationId)?.state ?? null;
+    }
+    async start(organizationId, projectId) {
+        await this.forget(organizationId);
+        const codeVerifier = randomBytes(32).toString('base64url');
+        const server = createServer((request, response) => {
+            void this.callback(organizationId, request, response);
+        });
+        await new Promise((resolvePromise, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', resolvePromise);
+        });
+        server.unref();
+        const port = server.address().port;
+        try {
+            const envelope = await this.client.request(endpoints.jiraConnect(organizationId), {
+                method: 'POST',
+                body: {
+                    codeChallenge: createHash('sha256').update(codeVerifier).digest('base64url'),
+                    callbackUrl: `http://127.0.0.1:${port}/callback`,
+                    ...(projectId ? { projectId } : {}),
+                },
+            });
+            const request = started.parse(envelope.data);
+            const state = {
+                phase: 'waiting',
+                connectUrl: request.connectUrl,
+                expiresAt: request.expiresAt,
+            };
+            const timer = setTimeout(() => void this.expire(organizationId, request.requestId), Math.max(0, Date.parse(request.expiresAt) - Date.now()));
+            timer.unref();
+            this.flows.set(organizationId, {
+                requestId: request.requestId,
+                codeVerifier,
+                port,
+                server,
+                timer,
+                state,
+            });
+            return state;
+        }
+        catch (error) {
+            await close(server);
+            throw error;
+        }
+    }
+    async forget(organizationId) {
+        const flow = this.flows.get(organizationId);
+        if (!flow)
+            return;
+        this.flows.delete(organizationId);
+        clearTimeout(flow.timer);
+        await close(flow.server);
+    }
+    async dispose() {
+        for (const organizationId of [...this.flows.keys()])
+            await this.forget(organizationId);
+    }
+    async expire(organizationId, requestId) {
+        const flow = this.flows.get(organizationId);
+        if (flow?.requestId !== requestId || flow.state.phase === 'finishing')
+            return;
+        if (flow.state.phase === 'waiting')
+            flow.state = { phase: 'expired' };
+        await close(flow.server);
+    }
+    async callback(organizationId, request, response) {
+        const flow = this.flows.get(organizationId);
+        try {
+            const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+            if (!flow ||
+                request.method !== 'GET' ||
+                request.headers.host !== `127.0.0.1:${flow.port}` ||
+                url.pathname !== '/callback' ||
+                url.searchParams.get('requestId') !== flow.requestId ||
+                flow.state.phase !== 'waiting' ||
+                Date.parse(flow.state.expiresAt) <= Date.now())
+                return this.send(response, 400, await this.page('invalid'));
+            const code = url.searchParams.get('code');
+            if (!code) {
+                const cancelled = url.searchParams.get('error') === 'cancelled';
+                flow.state = cancelled
+                    ? { phase: 'cancelled' }
+                    : {
+                        phase: 'failed',
+                        message: 'Atlassian did not finish the authorization. Start jira.connect again.',
+                        recovery: 'jira.connect',
+                    };
+                return this.finish(flow, response, await this.page(cancelled ? 'cancelled' : 'failed'));
+            }
+            flow.state = { phase: 'finishing' };
+            try {
+                const envelope = await this.client.request(endpoints.jiraConnectComplete(organizationId), {
+                    method: 'POST',
+                    body: { requestId: flow.requestId, code, codeVerifier: flow.codeVerifier },
+                });
+                const result = envelope.data ?? {};
+                flow.state = { phase: 'answered', result };
+                const connection = result.connection;
+                return this.finish(flow, response, result.outcome === 'connected'
+                    ? await this.page('connected', String(connection?.siteName ?? ''))
+                    : await this.page('chooseSite'));
+            }
+            catch (error) {
+                flow.state = {
+                    phase: 'failed',
+                    message: error instanceof Error ? error.message : 'The Jira connection failed.',
+                    recovery: error instanceof ApiResponseError ? error.recovery : null,
+                };
+                return this.finish(flow, response, await this.page('failed'), 502);
+            }
+        }
+        catch {
+            return this.send(response, 500, await this.page('failed'));
+        }
+    }
+    finish(flow, response, html, status = 200) {
+        clearTimeout(flow.timer);
+        response.once('finish', () => void close(flow.server));
+        this.send(response, status, html);
+    }
+    send(response, status, html) {
+        response.writeHead(status, {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Cache-Control': 'no-store',
+            'Referrer-Policy': 'no-referrer',
+            'X-Content-Type-Options': 'nosniff',
+            'Content-Security-Policy': "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'; base-uri 'none'",
+        });
+        response.end(html);
+    }
+    async page(notice, site = '') {
+        const told = await this.language().catch(() => undefined);
+        const { language, copy } = copies(pageWording, 'jiraConnect', told)[0];
+        const message = format(copy[notice], language, { site });
+        return (`<!doctype html><html lang="${escapeHtml(language)}" dir="${textDirection(language)}"><head>` +
+            '<meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">' +
+            `<title>${escapeHtml(copy.title)}</title><style>` +
+            'body{font:16px/1.5 system-ui,sans-serif;margin:0;padding:24px 16px;background:#f6f7f9;color:#1d2330}' +
+            'main{max-width:560px;margin:0 auto}h1{font-size:22px;line-height:1.3}' +
+            '@media (prefers-color-scheme:dark){body{background:#14171c;color:#e6e9ef}}' +
+            `</style></head><body><main><h1>${escapeHtml(copy.title)}</h1><p>${escapeHtml(message)}</p></main></body></html>`);
+    }
+}
+async function close(server) {
+    if (!server.listening)
+        return;
+    await new Promise((resolvePromise) => {
+        server.close(() => resolvePromise());
+        server.closeAllConnections();
+    });
+}
+//# sourceMappingURL=jira-connect.js.map

package/runtime/dist/src/runtime/api-client.js

@@ -9,6 +9,7 @@ export const backendRecoveryOperationNames = [
     'auth.web_signin',
     'audit.list',
     'live_status.list',
+    'jira.status',
     'organization.member_list',
     'organization.member_upsert',
     'project.setup',
@@ -95,6 +96,11 @@ export class ApiResponseError extends Error {
         this.recovery = normalizedRecovery;
     }
 }
+export function backendRejectsField(error, fields) {
+    return (error instanceof ApiResponseError &&
+        error.httpStatus === 400 &&
+        fields.some((field) => error.message.includes(`property ${field} should not exist`)));
+}
 export class ApiClient {
     options;
     fetchImplementation;