engineering-memory 1.11.30 → 1.11.31

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

@@ -0,0 +1,876 @@
+import * as z from 'zod/v4';
+import { assertSafeToPersist } from '../runtime/offline-outbox.js';
+import { languageTag, } from '../runtime/questionnaire-store.js';
+import { copies, format } from '../runtime/texts.js';
+import { sha256, stableStringify } from '../utilities/hash.js';
+import { answerData, askFailed, askQuestionnaire } from './questionnaire-tools.js';
+const line = z.string().trim().min(1);
+const choice = z.strictObject({ label: line, description: line });
+const question = { message: line, context: line, example: line };
+const wording = z.strictObject({
+    site: z.strictObject({ ...question, other: choice, addressTitle: line }),
+    linkSite: z.strictObject(question),
+    linkProject: z.strictObject({
+        ...question,
+        option: line,
+        other: choice,
+        none: choice,
+        keyTitle: line,
+    }),
+    replace: z.strictObject({ ...question, replace: choice, keep: choice }),
+    unlink: z.strictObject({ ...question, unlink: choice, keep: choice }),
+    disconnect: z.strictObject({ ...question, disconnect: choice, keep: choice }),
+    people: z.strictObject({
+        ...question,
+        person: line,
+        unnamed: line,
+        match: line,
+        other: choice,
+        none: choice,
+        handleTitle: line,
+    }),
+    again: z.strictObject({ unknown: line, ambiguous: line, context: line, example: line }),
+});
+const optionalRepoRoot = z.string().min(1).optional();
+const requestKey = z
+    .string()
+    .regex(/^[A-Za-z0-9_-]{1,80}$/)
+    .describe('A key you choose for this one request of the user. Reuse it unchanged to retry or to continue after the user answers; use a new one only when the user asks for this action again later.');
+const presentation = z.literal('host_native').optional();
+const site = z.object({ id: z.string(), url: z.string(), name: z.string() });
+const connectResult = z.object({
+    outcome: z.enum(['connected', 'site_choice_required']),
+    requestId: z.string(),
+    connection: z.object({ siteName: z.string() }).nullable(),
+    sites: z.array(site),
+    actingAs: z.string().nullable(),
+    reconnected: z.boolean(),
+    accountChanged: z.boolean(),
+});
+const projectState = z.object({
+    projectId: z.string(),
+    projectName: z.string(),
+    organizationId: z.string(),
+    configured: z.boolean(),
+    link: z
+        .object({
+        connectionId: z.string(),
+        siteName: z.string(),
+        jiraProjectId: z.string(),
+        jiraProjectKey: z.string(),
+        jiraProjectName: z.string(),
+        status: z.enum(['active', 'paused']),
+    })
+        .nullable(),
+    connections: z.array(z.object({ id: z.string(), siteName: z.string(), siteUrl: z.string() })),
+});
+const organizationStatus = z.object({
+    configured: z.boolean(),
+    connections: z.array(z.object({
+        id: z.string(),
+        siteName: z.string(),
+        status: z.enum(['active', 'needs_reconnect', 'disconnected']),
+        managedByYou: z.boolean(),
+        links: z.array(z.object({ status: z.enum(['active', 'paused']) })),
+        people: z.object({ unmapped: z.number(), mapped: z.number(), noCounterpart: z.number() }),
+    })),
+});
+const jiraProjects = z.object({
+    projects: z.array(z.object({ id: z.string(), key: z.string(), name: z.string() })),
+    more: z.boolean(),
+});
+const member = z.object({ userId: z.string(), handle: z.string() });
+const people = z.object({
+    siteName: z.string(),
+    complete: z.boolean(),
+    people: z.array(z.object({
+        accountId: z.string(),
+        displayName: z.string(),
+        decision: z.enum(['unmapped', 'mapped', 'no_counterpart']),
+        lockVersion: z.number(),
+        candidates: z.array(member),
+    })),
+    members: z.array(member),
+    counts: z.object({ unmapped: z.number(), mapped: z.number(), noCounterpart: z.number() }),
+});
+const notConfigured = 'Jira is not configured on this server. Its owner registers the Engineering Memory app with Atlassian and sets the three Jira settings described in the Jira connection guide; nothing else changes until then.';
+const shownPages = new Map();
+const shownPageLifetimeMs = 60 * 60 * 1000;
+export function registerJiraTools(server, service) {
+    server.registerTool('jira.status', {
+        description: 'Show the Jira connections of an organization and, for a project, which Jira project it follows. Without arguments it uses the project bound to this repository; with organizationId alone it shows only the organization. The answer names what to do next: connect, reconnect, link a project or match people. Any organization member may read it.',
+        inputSchema: z.strictObject({
+            repoRoot: optionalRepoRoot,
+            organizationId: z.uuid().optional(),
+            projectId: z.uuid().optional(),
+        }),
+    }, async (input) => status(service, input));
+    server.registerTool('jira.connect', {
+        description: 'Connect a Jira Cloud site to the organization of this project, or reconnect one that needs it. The first call returns a link: give it to the user to open in a browser on this computer, where Atlassian asks them to approve read access; never open it yourself. When they say they approved, call jira.connect again with the same arguments to see the result; if Atlassian granted several sites, it asks which one. Pass restart only to discard an unused link and start over, never when checking the result. An organization owner, or an owner or maintainer of the project, may connect. Tokens stay on the server; the chat never sees them.',
+        inputSchema: z.strictObject({
+            repoRoot: optionalRepoRoot,
+            organizationId: z.uuid().optional(),
+            projectId: z.uuid().optional(),
+            restart: z.boolean().optional(),
+            language: languageTag.optional(),
+            presentation,
+        }),
+    }, async (input, context) => connect(server, service, input, context));
+    server.registerTool('jira.disconnect', {
+        description: 'Disconnect one Jira site after the user confirms it in a native question. The stored access is deleted and every project linked through it is paused; work items, stages and people matches stay, and connecting the same site again restores them. Only the person who connected it or an organization owner may disconnect. Read the connection id with jira.status.',
+        inputSchema: z.strictObject({
+            repoRoot: optionalRepoRoot,
+            organizationId: z.uuid().optional(),
+            connectionId: z.uuid(),
+            requestKey,
+            language: languageTag.optional(),
+            presentation,
+        }),
+    }, async (input, context) => disconnect(server, service, input, context));
+    server.registerTool('jira.link_project', {
+        description: 'Link the project bound here, or projectId, to one Jira project, asking natively which site and which Jira project unless jiraProjectKey names it. Linking makes the statuses of the Jira project the stages of this project; stages that exist only in Engineering Memory stay, and nothing moves. Replacing an active link to another Jira project asks for confirmation. Project owners and maintainers may link through a connection they made or one an organization owner made.',
+        inputSchema: z.strictObject({
+            repoRoot: optionalRepoRoot,
+            projectId: z.uuid().optional(),
+            connectionId: z.uuid().optional(),
+            jiraProjectKey: z
+                .string()
+                .regex(/^[A-Za-z][A-Za-z0-9_]{0,31}$/)
+                .optional(),
+            requestKey,
+            language: languageTag.optional(),
+            presentation,
+        }),
+    }, async (input, context) => linkProject(server, service, input, context));
+    server.registerTool('jira.unlink_project', {
+        description: 'Stop following the Jira project of the project bound here, or projectId, after the user confirms it in a native question. The link is paused, not deleted: stages and work stay, and linking the same Jira project again resumes it.',
+        inputSchema: z.strictObject({
+            repoRoot: optionalRepoRoot,
+            projectId: z.uuid().optional(),
+            requestKey,
+            language: languageTag.optional(),
+            presentation,
+        }),
+    }, async (input, context) => unlinkProject(server, service, input, context));
+    server.registerTool('jira.map_people', {
+        description: 'Match the people who hold open Jira issues in the linked projects of one connection with members of the organization, in native forms of up to eight people. Each person is offered up to two similar members, "someone else" to type the part of the e-mail before @, and "no one in Engineering Memory". Nothing is matched without the answer. Continue by calling it again with the same arguments until it reports done. Only the person who connected the site or an organization owner may match. Read the connection id with jira.status.',
+        inputSchema: z.strictObject({
+            repoRoot: optionalRepoRoot,
+            organizationId: z.uuid().optional(),
+            connectionId: z.uuid(),
+            requestKey,
+            language: languageTag.optional(),
+            presentation,
+        }),
+    }, async (input, context) => mapPeople(server, service, input, context));
+}
+async function status(service, input) {
+    let project = null;
+    let projectData = null;
+    if (!input.organizationId || input.projectId) {
+        const state = await service.jiraProjectState(input);
+        if (!state.ok)
+            return output(state);
+        const parsed = projectState.safeParse(state.data);
+        if (!parsed.success)
+            return unexpected();
+        project = parsed.data;
+        projectData = state.data ?? null;
+    }
+    const organizationId = input.organizationId ?? project.organizationId;
+    const organization = await service.jiraOrganizationStatus(organizationId);
+    if (!organization.ok)
+        return output(organization);
+    const parsed = organizationStatus.safeParse(organization.data);
+    if (!parsed.success)
+        return unexpected();
+    return output({
+        ok: true,
+        data: {
+            organization: organization.data ?? null,
+            project: projectData,
+            nextAction: nextSteps(parsed.data, project),
+        },
+    });
+}
+function nextSteps(organization, project) {
+    if (!organization.configured)
+        return notConfigured;
+    const steps = [];
+    const active = organization.connections.filter((connection) => connection.status === 'active');
+    if (!active.length)
+        steps.push('No Jira site is connected: jira.connect connects one (an organization owner, or an owner or maintainer of a project).');
+    for (const connection of organization.connections)
+        if (connection.status === 'needs_reconnect')
+            steps.push(`${connection.siteName} needs to be connected again: jira.connect with the same Atlassian site restores it.`);
+    if (project && !project.link)
+        steps.push('This project follows no Jira project: jira.link_project links it.');
+    if (project?.link?.status === 'paused')
+        steps.push(`The link to ${project.link.jiraProjectKey} is paused: jira.link_project links it again.`);
+    for (const connection of active)
+        if (connection.managedByYou &&
+            connection.links.some((link) => link.status === 'active') &&
+            (connection.people.unmapped > 0 ||
+                connection.people.mapped + connection.people.noCounterpart === 0))
+            steps.push(`The Jira people of ${connection.siteName} are not all matched with members: jira.map_people matches them.`);
+    return steps.join(' ') || 'Jira is connected and nothing waits for the user.';
+}
+async function connect(server, service, input, context) {
+    let organizationId = input.organizationId;
+    let projectId = null;
+    if (!organizationId || input.projectId) {
+        const state = await service.jiraProjectState(input);
+        if (!state.ok)
+            return output(state);
+        const project = projectState.safeParse(state.data);
+        if (!project.success)
+            return unexpected();
+        if (!project.data.configured)
+            return refusal(notConfigured, 'jira.status');
+        if (organizationId && organizationId !== project.data.organizationId)
+            return refusal('This project belongs to another organization. Name only the organizationId, or only the projectId.', 'jira.status');
+        organizationId = project.data.organizationId;
+        projectId = project.data.projectId;
+    }
+    const started = await service.jiraConnectStart({
+        organizationId,
+        projectId,
+        restart: input.restart ?? false,
+    });
+    if (!started.ok)
+        return output(started);
+    const state = started.data;
+    if (state.phase === 'waiting')
+        return output({
+            ok: true,
+            data: {
+                status: 'waiting',
+                connectUrl: state.connectUrl,
+                expiresAt: state.expiresAt,
+                nextAction: 'Give this link to the user to open in a browser on this computer. Atlassian asks them to choose the Jira site and approve read access for Engineering Memory; the link works once, for 15 minutes. Never open it yourself. When the user says they approved, call jira.connect again with the same arguments, without restart.',
+            },
+        });
+    if (state.phase === 'finishing')
+        return output({
+            ok: true,
+            data: {
+                status: 'finishing',
+                nextAction: 'Atlassian answered and the connection is being finished. Call jira.connect again with the same arguments in a few seconds.',
+            },
+        });
+    if (state.phase !== 'answered') {
+        await service.jiraConnectForget(organizationId);
+        if (state.phase === 'failed')
+            return refusal(state.message, state.recovery ?? 'jira.status', 'jira_connect');
+        return output({
+            ok: true,
+            data: {
+                status: state.phase,
+                nextAction: 'Nothing was connected. Call jira.connect again only if the user wants to try again.',
+            },
+        });
+    }
+    const result = connectResult.safeParse(state.result);
+    if (!result.success) {
+        await service.jiraConnectForget(organizationId);
+        return unexpected();
+    }
+    if (result.data.outcome === 'connected') {
+        await service.jiraConnectForget(organizationId);
+        return connected(state.result);
+    }
+    const told = await service.language(input.language);
+    const { language, copy } = wordingFor(told);
+    const sites = [...result.data.sites].sort((a, b) => a.name.localeCompare(b.name));
+    const listed = sites.length > 12 ? sites.slice(0, 11) : sites;
+    const { repoRoot: _repoRoot, presentation: _presentation, ...retryArguments } = input;
+    const answer = await askQuestionnaire(server, service, {
+        questionnaireId: 'jira-site-' + result.data.requestId,
+        language,
+        impact: 'routine',
+        message: copy.site.message,
+        context: copy.site.context,
+        example: format(copy.site.example, language, { site: listed[0].name }),
+        options: [
+            ...listed.map((entry) => ({ id: entry.id, label: entry.name, description: entry.url })),
+            ...(listed.length < sites.length
+                ? [
+                    {
+                        id: 'other',
+                        label: copy.site.other.label,
+                        description: copy.site.other.description,
+                    },
+                ]
+                : []),
+        ],
+        ...(listed.length < sites.length
+            ? {
+                textField: {
+                    title: copy.site.addressTitle,
+                    maxLength: 200,
+                    requiredForChoice: 'other',
+                },
+            }
+            : {}),
+        binding: { organizationId, requestId: result.data.requestId },
+        repoRoot: input.repoRoot,
+        presentation: input.presentation,
+    }, context, [], { tool: 'jira.connect', retryArguments });
+    const picked = answerData(answer);
+    if (!picked?.choice)
+        return answer;
+    const host = (address) => address
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, '')
+        .replace(/\/.*$/, '');
+    const chosen = picked.choice === 'other'
+        ? sites.find((entry) => host(entry.url) === host(picked.text ?? ''))
+        : sites.find((entry) => entry.id === picked.choice);
+    if (!chosen) {
+        await service.jiraConnectForget(organizationId);
+        return refusal('The typed address is not one of the sites Atlassian granted. Start again with jira.connect and choose the site from the list.', 'jira.connect');
+    }
+    const finished = await service.jiraChooseSite({
+        organizationId,
+        requestId: result.data.requestId,
+        cloudId: chosen.id,
+    });
+    await service.jiraConnectForget(organizationId);
+    if (!finished.ok)
+        return output(finished);
+    return connected(finished.data);
+}
+function connected(data) {
+    const result = connectResult.parse(data);
+    const site = result.connection?.siteName ?? '';
+    return output({
+        ok: true,
+        data: {
+            status: 'connected',
+            connection: data.connection ?? null,
+            actingAs: result.actingAs,
+            reconnected: result.reconnected,
+            accountChanged: result.accountChanged,
+            nextAction: `Tell the user that ${site} is connected` +
+                (result.actingAs ? ` and acts as the Atlassian account ${result.actingAs}` : '') +
+                '.' +
+                (result.accountChanged
+                    ? ' It now acts as a different Atlassian account than before, so it sees what that account sees.'
+                    : '') +
+                ' Next, link a project with jira.link_project, then match people with jira.map_people.',
+        },
+    });
+}
+async function disconnect(server, service, input, context) {
+    const organizationId = await organizationOf(service, input);
+    if (typeof organizationId !== 'string')
+        return organizationId;
+    const current = await service.jiraOrganizationStatus(organizationId);
+    if (!current.ok)
+        return output(current);
+    const parsed = organizationStatus.safeParse(current.data);
+    if (!parsed.success)
+        return unexpected();
+    const connection = parsed.data.connections.find((entry) => entry.id === input.connectionId);
+    if (!connection)
+        return refusal('This organization has no Jira connection with that id. Read the connections with jira.status.', 'jira.status');
+    if (connection.status === 'disconnected')
+        return output({ ok: true, data: { status: 'already_disconnected' } });
+    const told = await service.language(input.language);
+    const { language, copy } = wordingFor(told);
+    const values = { site: connection.siteName };
+    const answer = await ask(server, service, input, context, 'jira.disconnect', {
+        questionnaireId: 'jira-disconnect-' +
+            sha256(stableStringify({ requestKey: input.requestKey, organizationId, id: connection.id })),
+        language,
+        impact: 'critical',
+        message: format(copy.disconnect.message, language, values),
+        context: format(copy.disconnect.context, language, values),
+        example: format(copy.disconnect.example, language, values),
+        options: [
+            option('keep', copy.disconnect.keep),
+            option('disconnect', copy.disconnect.disconnect),
+        ],
+        binding: { organizationId, connectionId: connection.id },
+    });
+    const picked = answerData(answer)?.choice;
+    if (!picked)
+        return answer;
+    if (picked === 'keep')
+        return output({ ok: true, data: { status: 'kept' } });
+    const result = await service.jiraDisconnect({ organizationId, connectionId: connection.id });
+    if (!result.ok)
+        return output(result);
+    return output({
+        ok: true,
+        data: {
+            status: 'disconnected',
+            connection: result.data ?? null,
+            nextAction: 'Tell the user it is disconnected. Atlassian offers no call to withdraw the approval, so to remove Engineering Memory from the Atlassian account too, they open id.atlassian.com, then Connected apps.',
+        },
+    });
+}
+async function linkProject(server, service, input, context) {
+    const state = await service.jiraProjectState(input);
+    if (!state.ok)
+        return output(state);
+    const parsed = projectState.safeParse(state.data);
+    if (!parsed.success)
+        return unexpected();
+    const project = parsed.data;
+    if (!project.configured)
+        return refusal(notConfigured, 'jira.status');
+    if (!project.connections.length)
+        return refusal('No Jira connection in this organization can be linked by this person. Connect a site with jira.connect, or ask the organization owner or whoever connected the site.', 'jira.connect');
+    const told = await service.language(input.language);
+    const { language, copy } = wordingFor(told);
+    const values = { project: project.projectName };
+    const base = { requestKey: input.requestKey, projectId: project.projectId };
+    let connection = project.connections.find((entry) => entry.id === (input.connectionId ?? project.connections[0].id));
+    if (!connection)
+        return refusal('That Jira connection cannot be linked by this person. Read the usable ones with jira.status.', 'jira.status');
+    if (!input.connectionId && project.connections.length > 1) {
+        const listed = project.connections.slice(0, 12);
+        const answer = await ask(server, service, input, context, 'jira.link_project', {
+            questionnaireId: 'jira-link-site-' +
+                sha256(stableStringify({ ...base, connections: listed.map((entry) => entry.id) })),
+            language,
+            impact: 'routine',
+            message: format(copy.linkSite.message, language, values),
+            context: copy.linkSite.context,
+            example: format(copy.linkSite.example, language, { site: listed[0].siteName }),
+            options: listed.map((entry) => ({
+                id: entry.id,
+                label: entry.siteName,
+                description: entry.siteUrl,
+            })),
+            binding: { projectId: project.projectId },
+        });
+        const picked = answerData(answer)?.choice;
+        if (!picked)
+            return answer;
+        connection = listed.find((entry) => entry.id === picked);
+    }
+    let jiraProject;
+    let typedKey = input.jiraProjectKey?.toUpperCase();
+    if (!typedKey) {
+        const listing = await service.jiraProjects({
+            projectId: project.projectId,
+            connectionId: connection.id,
+        });
+        if (!listing.ok)
+            return output(listing);
+        const found = jiraProjects.safeParse(listing.data);
+        if (!found.success)
+            return unexpected();
+        const { projects, more } = found.data;
+        if (!projects.length)
+            return refusal(`The Atlassian account behind ${connection.siteName} sees no Jira project. Give it access in Jira, or connect with another account using jira.connect.`, 'jira.connect');
+        const answer = await ask(server, service, input, context, 'jira.link_project', {
+            questionnaireId: 'jira-link-project-' +
+                sha256(stableStringify({ ...base, connectionId: connection.id, projects, more })),
+            language,
+            impact: 'routine',
+            message: format(copy.linkProject.message, language, values),
+            context: copy.linkProject.context,
+            example: format(copy.linkProject.example, language, {
+                ...values,
+                key: projects[0].key,
+            }),
+            options: [
+                ...projects.map((entry) => ({
+                    id: 'jira-' + entry.id,
+                    label: `${entry.name} (${entry.key})`,
+                    description: format(copy.linkProject.option, language, { ...values, key: entry.key }),
+                })),
+                ...(more
+                    ? [option('other', copy.linkProject.other)]
+                    : projects.length === 1
+                        ? [option('none', copy.linkProject.none)]
+                        : []),
+            ],
+            ...(more
+                ? {
+                    textField: {
+                        title: copy.linkProject.keyTitle,
+                        maxLength: 32,
+                        requiredForChoice: 'other',
+                    },
+                }
+                : {}),
+            binding: { projectId: project.projectId, connectionId: connection.id },
+        });
+        const picked = answerData(answer);
+        if (!picked?.choice)
+            return answer;
+        if (picked.choice === 'none')
+            return output({ ok: true, data: { status: 'not_linked' } });
+        if (picked.choice === 'other')
+            typedKey = picked.text?.trim().toUpperCase();
+        else
+            jiraProject = projects.find((entry) => 'jira-' + entry.id === picked.choice);
+    }
+    if (!jiraProject) {
+        if (!typedKey || !/^[A-Z][A-Z0-9_]{0,31}$/.test(typedKey))
+            return refusal('A Jira project key is letters and digits, such as KAN. Call jira.link_project again with jiraProjectKey and a new requestKey.', 'jira.link_project');
+        const lookup = await service.jiraProjects({
+            projectId: project.projectId,
+            connectionId: connection.id,
+            key: typedKey,
+        });
+        if (!lookup.ok)
+            return output(lookup);
+        const found = jiraProjects.safeParse(lookup.data);
+        if (!found.success)
+            return unexpected();
+        jiraProject = found.data.projects[0];
+        if (!jiraProject)
+            return refusal(`${connection.siteName} has no Jira project ${typedKey} that the connected account can see. Check the key and call jira.link_project again with a new requestKey.`, 'jira.link_project');
+    }
+    const current = project.link;
+    const replace = current?.status === 'active' &&
+        (current.connectionId !== connection.id || current.jiraProjectId !== jiraProject.id);
+    if (replace) {
+        const swap = {
+            ...values,
+            current: current.jiraProjectKey,
+            next: jiraProject.key,
+        };
+        const answer = await ask(server, service, input, context, 'jira.link_project', {
+            questionnaireId: 'jira-link-replace-' +
+                sha256(stableStringify({
+                    ...base,
+                    from: [current.connectionId, current.jiraProjectId],
+                    to: [connection.id, jiraProject.id],
+                })),
+            language,
+            impact: 'critical',
+            message: format(copy.replace.message, language, swap),
+            context: format(copy.replace.context, language, swap),
+            example: format(copy.replace.example, language, swap),
+            options: [
+                option('keep', copy.replace.keep, swap, language),
+                option('replace', copy.replace.replace, swap, language),
+            ],
+            binding: { projectId: project.projectId, connectionId: connection.id },
+        });
+        const picked = answerData(answer)?.choice;
+        if (!picked)
+            return answer;
+        if (picked === 'keep')
+            return output({ ok: true, data: { status: 'kept', link: current } });
+    }
+    const linked = await service.jiraLink({
+        projectId: project.projectId,
+        connectionId: connection.id,
+        jiraProjectId: jiraProject.id,
+        replace,
+    });
+    if (!linked.ok)
+        return output(linked);
+    return output({
+        ok: true,
+        data: {
+            status: 'linked',
+            ...linked.data,
+            nextAction: 'Tell the user which Jira project is linked and which stages were added, renamed, restored or archived. Then offer, one at a time and only as they want: the roles that move work automatically (work_item.setup_workflow; rolesOnLocalStatuses lists roles still aimed at stages that exist only in Engineering Memory), what a stage means (work_item.describe_status), moving work out of stages that exist only in Engineering Memory (work_item.remap_statuses), the stage new work starts in (work_item.set_initial_status), and matching people (jira.map_people).',
+        },
+    });
+}
+async function unlinkProject(server, service, input, context) {
+    const state = await service.jiraProjectState(input);
+    if (!state.ok)
+        return output(state);
+    const parsed = projectState.safeParse(state.data);
+    if (!parsed.success)
+        return unexpected();
+    const project = parsed.data;
+    if (project.link?.status !== 'active')
+        return output({ ok: true, data: { status: 'not_linked', link: project.link } });
+    const told = await service.language(input.language);
+    const { language, copy } = wordingFor(told);
+    const values = { project: project.projectName, current: project.link.jiraProjectKey };
+    const answer = await ask(server, service, input, context, 'jira.unlink_project', {
+        questionnaireId: 'jira-unlink-' +
+            sha256(stableStringify({
+                requestKey: input.requestKey,
+                projectId: project.projectId,
+                link: [project.link.connectionId, project.link.jiraProjectId],
+            })),
+        language,
+        impact: 'critical',
+        message: format(copy.unlink.message, language, values),
+        context: copy.unlink.context,
+        example: format(copy.unlink.example, language, values),
+        options: [option('keep', copy.unlink.keep), option('unlink', copy.unlink.unlink)],
+        binding: { projectId: project.projectId },
+    });
+    const picked = answerData(answer)?.choice;
+    if (!picked)
+        return answer;
+    if (picked === 'keep')
+        return output({ ok: true, data: { status: 'kept', link: project.link } });
+    const result = await service.jiraUnlink(project.projectId);
+    if (!result.ok)
+        return output(result);
+    return output({ ok: true, data: { status: 'unlinked', link: result.data ?? null } });
+}
+async function mapPeople(server, service, input, context) {
+    const organizationId = await organizationOf(service, input);
+    if (typeof organizationId !== 'string')
+        return organizationId;
+    const told = await service.language(input.language);
+    const { language, copy } = wordingFor(told);
+    const key = [organizationId, input.connectionId, input.requestKey].join(':');
+    const applied = { mapped: 0, noCounterpart: 0 };
+    for (let round = 0; round < 20; round++) {
+        let page = shownPages.get(key);
+        if (!page || Date.now() - page.shownAt > shownPageLifetimeMs) {
+            const response = await service.jiraPeople({
+                organizationId,
+                connectionId: input.connectionId,
+            });
+            if (!response.ok)
+                return output(response);
+            const found = people.safeParse(response.data);
+            if (!found.success)
+                return unexpected();
+            const open = found.data.people.filter((person) => person.decision === 'unmapped');
+            if (!open.length) {
+                shownPages.delete(key);
+                return output({
+                    ok: true,
+                    data: {
+                        status: 'done',
+                        appliedNow: applied,
+                        counts: found.data.counts,
+                        complete: found.data.complete,
+                        nextAction: found.data.complete
+                            ? 'Every person holding open Jira issues in the linked projects is matched or marked as having no member.'
+                            : 'Jira was read up to its limit for one run, so some people may not have been seen yet. Call jira.map_people again later with a new requestKey.',
+                    },
+                });
+            }
+            page = {
+                people: open.slice(0, 8),
+                members: found.data.members,
+                siteName: found.data.siteName,
+                remaining: open.length,
+                shownAt: Date.now(),
+            };
+            for (const [shownKey, shown] of shownPages)
+                if (Date.now() - shown.shownAt > shownPageLifetimeMs)
+                    shownPages.delete(shownKey);
+            shownPages.set(key, page);
+        }
+        const form = {
+            questionnaireId: 'jira-people-' +
+                sha256(stableStringify({
+                    requestKey: input.requestKey,
+                    organizationId,
+                    connectionId: input.connectionId,
+                    people: page.people,
+                })),
+            language,
+            impact: 'routine',
+            message: format(copy.people.message, language, {
+                site: page.siteName,
+                count: page.remaining,
+                shown: page.people.length,
+            }),
+            context: copy.people.context,
+            example: copy.people.example,
+            questions: page.people.map((person, index) => ({
+                id: `person${index + 1}`,
+                message: format(copy.people.person, language, {
+                    name: shownName(person.displayName, index, copy, language),
+                }),
+                options: [
+                    ...person.candidates.slice(0, 2).map((candidate) => ({
+                        id: 'member-' + candidate.userId,
+                        label: candidate.handle,
+                        description: format(copy.people.match, language, { handle: candidate.handle }),
+                    })),
+                    option('other', copy.people.other),
+                    option('none', copy.people.none),
+                ],
+                otherAsText: true,
+                textField: { title: copy.people.handleTitle, maxLength: 120, requiredForChoice: 'other' },
+            })),
+            binding: { organizationId, connectionId: input.connectionId },
+        };
+        const answer = await ask(server, service, input, context, 'jira.map_people', form);
+        const answers = formAnswers(answer);
+        if (!answers)
+            return privacyRefusal(answer) ?? answer;
+        const decisions = [];
+        for (const [index, person] of page.people.entries()) {
+            let picked = answers[`person${index + 1}`];
+            let parent = form.questionnaireId;
+            for (let attempt = 0; attempt < 5 && picked; attempt++) {
+                const decided = decision(picked, page.members);
+                if ('userId' in decided || 'noCounterpart' in decided) {
+                    decisions.push({
+                        accountId: person.accountId,
+                        lockVersion: person.lockVersion,
+                        ...decided,
+                    });
+                    break;
+                }
+                const again = {
+                    questionnaireId: 'jira-person-' +
+                        sha256(stableStringify({ parent, accountId: person.accountId, typed: decided.typed })),
+                    language,
+                    impact: 'routine',
+                    message: format(decided.ambiguous ? copy.again.ambiguous : copy.again.unknown, language, {
+                        name: shownName(person.displayName, index, copy, language),
+                        typed: decided.typed,
+                    }),
+                    context: copy.again.context,
+                    example: copy.again.example,
+                    options: [
+                        ...decided.matches.map((entry) => ({
+                            id: 'member-' + entry.userId,
+                            label: entry.handle,
+                            description: format(copy.people.match, language, { handle: entry.handle }),
+                        })),
+                        option('other', copy.people.other),
+                        option('none', copy.people.none),
+                    ],
+                    textField: { title: copy.people.handleTitle, maxLength: 120, requiredForChoice: 'other' },
+                    binding: { organizationId, connectionId: input.connectionId },
+                };
+                const followUp = await ask(server, service, input, context, 'jira.map_people', again);
+                picked = answerData(followUp);
+                if (!picked)
+                    return privacyRefusal(followUp) ?? followUp;
+                parent = again.questionnaireId;
+            }
+        }
+        shownPages.delete(key);
+        if (!decisions.length)
+            return output({
+                ok: true,
+                data: {
+                    status: 'undecided',
+                    nextAction: 'No member could be identified for these people. Call jira.map_people again with a new requestKey when the user knows who they are.',
+                },
+            });
+        const result = await service.jiraDecidePeople({
+            organizationId,
+            connectionId: input.connectionId,
+            decisions,
+        });
+        if (!result.ok)
+            return output(result);
+        for (const entry of decisions)
+            if (entry.userId)
+                applied.mapped++;
+            else
+                applied.noCounterpart++;
+    }
+    return output({
+        ok: true,
+        data: {
+            status: 'continue',
+            appliedNow: applied,
+            nextAction: 'Call jira.map_people again with the same arguments to continue.',
+        },
+    });
+}
+function decision(picked, members) {
+    if (picked.choice === 'none')
+        return { noCounterpart: true };
+    const listed = members.find((entry) => 'member-' + entry.userId === picked.choice);
+    if (listed)
+        return { userId: listed.userId };
+    const typed = (picked.text ?? '').trim().replace(/^@/, '').split('@')[0].trim().toLowerCase();
+    const exact = members.filter((entry) => entry.handle.toLowerCase() === typed);
+    if (exact.length === 1)
+        return { userId: exact[0].userId };
+    const local = members.filter((entry) => entry.handle.toLowerCase().split(' (')[0] === typed);
+    if (local.length === 1)
+        return { userId: local[0].userId };
+    if (local.length > 1)
+        return { typed, ambiguous: true, matches: local.slice(0, 10) };
+    return {
+        typed,
+        ambiguous: false,
+        matches: typed
+            ? members.filter((entry) => entry.handle.toLowerCase().includes(typed)).slice(0, 10)
+            : [],
+    };
+}
+function shownName(name, index, copy, language) {
+    const shown = name.split('@')[0].trim();
+    let safe = shown.length > 0;
+    try {
+        assertSafeToPersist(shown, 'message', '', true);
+    }
+    catch {
+        safe = false;
+    }
+    return safe ? shown : format(copy.people.unnamed, language, { number: index + 1 });
+}
+async function organizationOf(service, input) {
+    if (input.organizationId)
+        return input.organizationId;
+    const state = await service.jiraProjectState({ repoRoot: input.repoRoot });
+    if (!state.ok)
+        return output(state);
+    const project = projectState.safeParse(state.data);
+    if (!project.success)
+        return unexpected();
+    return project.data.organizationId;
+}
+async function ask(server, service, input, context, tool, definition) {
+    const { repoRoot: _repoRoot, presentation: _presentation, ...retryArguments } = input;
+    const owner = { tool, retryArguments };
+    return askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot, presentation: input.presentation }, context, [], owner);
+}
+function formAnswers(result) {
+    const text = result.content?.find((item) => item.type === 'text')?.text;
+    if (!text)
+        return undefined;
+    try {
+        const value = JSON.parse(text);
+        return value.ok && value.data?.status === 'answered' && value.data.answerAvailable
+            ? value.data.answers
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function privacyRefusal(result) {
+    if (!askFailed(result))
+        return undefined;
+    const text = result.content[0].text;
+    if (!text.includes('cannot be persisted'))
+        return undefined;
+    return refusal('An answer contained a full e-mail address or other contact data, which forms do not keep. Type only the part of the e-mail before @, then call jira.map_people again with the same arguments to see the same form.', 'jira.map_people', 'jira_people');
+}
+function wordingFor(language) {
+    return copies(wording, 'jira', language)[0];
+}
+function option(id, copy, values = {}, language = 'en') {
+    return {
+        id,
+        label: format(copy.label, language, values),
+        description: format(copy.description, language, values),
+    };
+}
+function unexpected() {
+    return refusal('The server answered Jira in a shape this version does not know. Update Engineering Memory and try again.', 'jira.status');
+}
+function refusal(message, recovery, kind = 'jira') {
+    return output({ ok: false, error: { kind, message, recovery, retryable: false } });
+}
+function output(result) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+        isError: !result.ok,
+    };
+}
+//# sourceMappingURL=jira-tools.js.map