ticketlens 0.26.0 → 0.30.0

package/skills/jtb/scripts/lib/help.mjs

@@ -53,11 +53,14 @@ export function printHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('ticketlens')} recall ${s.dim('<query|TICKET-KEY>')}   Search your saved Recall notes  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} recall sync                 Retry any notes stuck in the local queue  ${s.dim('[Team+]')}`,
     `    ${s.brand('ticketlens')} recall settings             Show effective retry-queue settings, fetched live  ${s.dim('[Team+]')}`,
-    `    ${s.brand('ticketlens')} mcp                         Start the MCP stdio server for Recall  ${s.dim('[Pro]')}`,
+    `    ${s.brand('ticketlens')} mcp                         Start the MCP stdio server (Recall + ticket writes)  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} comment ${s.dim('<TICKET-KEY> --body=...')}  Post a comment to the tracker  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} transition ${s.dim('<TICKET-KEY> [--target=... --confirm]')}  Move ticket status  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} assign ${s.dim('<TICKET-KEY> --to=me')}      Assign a ticket to yourself  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} duplicates ${s.dim('<TICKET-KEY> [--threshold=N]')}  Find likely duplicate tickets  ${s.dim('[Pro]')}`,
+    `    ${s.brand('ticketlens')} link ${s.dim('<SOURCE> <TARGET> [--type=... --confirm]')}  Link two tickets  ${s.dim('[Pro]')}`,
+    `    ${s.brand('ticketlens')} update ${s.dim('<TICKET-KEY> [--title=... --description=... --priority=... --add-labels=... --remove-labels=...]')}  Update fields  ${s.dim('[Pro]')}`,
+    `    ${s.brand('ticketlens')} create ${s.dim('--project=... [--type=...] --summary=... [--description=...]')}  Create a new ticket  ${s.dim('[Pro]')}`,
     '',
     `    ${s.brand('ticketlens')} delete ${s.dim('<PROFILE-NAME>')}       Remove a profile`,
     `    ${s.brand('ticketlens')} activate ${s.dim('<KEY>')}              Activate a license key`,
@@ -178,6 +181,7 @@ export function printFetchHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('--cloud')}            Route AI request through TicketLens API ${s.dim('[Pro]')}`,
     `    ${s.brand('--provider')}=${s.dim('NAME')}    Force AI provider ${s.dim('(anthropic|openai|groq)')}`,
     `    ${s.brand('--template')}=${s.dim('SLUG')}    Apply a brief template ${s.dim('(full|quick|code-review, or custom [Team])')}`,
+    `    ${s.brand('--budget')}=${s.dim('N')}         Trim brief to fit a token budget  ${s.dim('[Pro]')}`,
     `    ${s.brand('-h')}, ${s.brand('--help')}         Show this help`,
     '',
     `  ${s.bold('EXAMPLES')}`,
@@ -193,6 +197,32 @@ export function printFetchHelp({ stream = process.stdout } = {}) {
   stream.write(lines.join('\n') + '\n');
 }
 
+export function printHistoryHelp({ stream = process.stdout } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const lines = [
+    '',
+    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('history')} ${s.dim('TICKET-KEY')}  ${s.dim('[Pro]')}`,
+    '',
+    `  Show this ticket's urgency timeline from your local triage history — ${s.dim('[Pro]')}`,
+    `  every prior triage scan that surfaced it, with the urgency level and reason`,
+    `  computed at that point in time. Read-only, entirely local — no network call.`,
+    '',
+    `  ${s.bold('ARGUMENTS')}`,
+    '',
+    `    ${s.brand('TICKET-KEY')}   The ticket to show history for ${s.dim('(required)')}`,
+    '',
+    `  ${s.bold('OPTIONS')}`,
+    '',
+    `    ${s.brand('-h')}, ${s.brand('--help')}   Show this help`,
+    '',
+    `  ${s.bold('EXAMPLES')}`,
+    '',
+    `    ${s.dim('$')} ticketlens history PROJ-123`,
+    '',
+  ];
+  stream.write(lines.join('\n') + '\n');
+}
+
 const ANSI_RE_HELP = /\x1b\[[0-9;]*m/g;
 function padRightVis(str, len) {
   const vis = str.replace(ANSI_RE_HELP, '').length;
@@ -598,12 +628,16 @@ export function printMcpHelp({ stream = process.stdout } = {}) {
     '',
     `  Start an MCP (Model Context Protocol) stdio server exposing Recall and`,
     `  ticket writes as native tools — ${s.cyan('recall_add')}, ${s.cyan('recall_search')}, ${s.cyan('ticket_comment')},`,
-    `  ${s.cyan('ticket_transition')}, ${s.cyan('ticket_assign')}, ${s.cyan('ticket_duplicates')} — for any MCP-compatible AI`,
-    `  harness, not just Claude Code. Thin adapter over the same code as`,
-    `  ${s.cyan('note add')}/${s.cyan('recall')}/${s.cyan('comment')}/${s.cyan('transition')}/${s.cyan('assign')}/${s.cyan('duplicates')} above: same Pro gate, same`,
-    `  local vault/tracker writes, same team sync. ${s.cyan('ticket_transition')} is destructive when`,
-    `  called with \`target\`+\`confirm: true\`; ${s.cyan('ticket_assign')} is currently self-assign only;`,
-    `  ${s.cyan('ticket_duplicates')} is read-only.`,
+    `  ${s.cyan('ticket_transition')}, ${s.cyan('ticket_assign')}, ${s.cyan('ticket_duplicates')}, ${s.cyan('ticket_link')}, ${s.cyan('ticket_update')}, ${s.cyan('ticket_create')} — for any`,
+    `  MCP-compatible AI harness, not just Claude Code. Thin adapter over the same`,
+    `  code as ${s.cyan('note add')}/${s.cyan('recall')}/${s.cyan('comment')}/${s.cyan('transition')}/${s.cyan('assign')}/${s.cyan('duplicates')}/${s.cyan('link')}/${s.cyan('update')}/${s.cyan('create')} above:`,
+    `  same Pro gate, same local vault/tracker writes, same team sync. ${s.cyan('ticket_transition')} is`,
+    `  destructive when called with \`target\`+\`confirm: true\`; ${s.cyan('ticket_assign')} is currently`,
+    `  self-assign only; ${s.cyan('ticket_duplicates')} is read-only; ${s.cyan('ticket_link')} on GitHub closes the`,
+    `  source issue as a duplicate — different semantics than Jira/Linear's relationship-only`,
+    `  add; ${s.cyan('ticket_update')} has no priority field on GitHub and can partially succeed;`,
+    `  ${s.cyan('ticket_create')} has no ticket key to target — --profile/the default profile picks the`,
+    `  tracker, and it fabricates a real item, the highest blast radius of this family.`,
     `  Long-running — exits when the client closes stdin.`,
     '',
     `  ${s.bold('OPTIONS')}`,
@@ -730,6 +764,114 @@ export function printDuplicatesHelp({ stream = process.stdout } = {}) {
   stream.write(lines.join('\n') + '\n');
 }
 
+export function printLinkHelp({ stream = process.stdout } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const lines = [
+    '',
+    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('link')} ${s.dim('SOURCE-KEY TARGET-KEY [--type="..." --confirm]')}  ${s.dim('[Pro]')}`,
+    '',
+    `  Link two tickets in their tracker (Jira/GitHub/Linear). ${s.dim('[Pro]')}`,
+    `  Called with just SOURCE and TARGET, lists the tracker's current valid`,
+    `  link types without changing anything. Add ${s.brand('--type')} and ${s.brand('--confirm')} together to execute.`,
+    '',
+    `  ${s.bold('Direction matters')}: SOURCE "types" TARGET — e.g. \`link A B --type=Duplicate\` means`,
+    `  A duplicates B, not the other way around.`,
+    '',
+    `  ${s.bold('GitHub is different')}: it has no generic link relationship. Linking on a`,
+    `  GitHub-tracked ticket CLOSES SOURCE as a duplicate of TARGET — a state`,
+    `  change, not just a relationship add like Jira/Linear.`,
+    '',
+    `  ${s.bold('OPTIONS')}`,
+    '',
+    `    ${s.brand('--type')}=${s.dim('NAME')}    Link type ${s.dim('(from the list, case-insensitive; GitHub only supports "duplicate")')}`,
+    `    ${s.brand('--confirm')}     Required alongside --type to actually execute`,
+    `    ${s.brand('--profile')}=${s.dim('NAME')} Connection profile to use ${s.dim('(optional)')}`,
+    `    ${s.brand('-h')}, ${s.brand('--help')}   Show this help`,
+    '',
+    `  ${s.bold('EXAMPLES')}`,
+    '',
+    `    ${s.dim('$')} ticketlens link PROD-123 PROD-456`,
+    `    ${s.dim('$')} ticketlens link PROD-123 PROD-456 --type="Duplicate" --confirm`,
+    '',
+  ];
+  stream.write(lines.join('\n') + '\n');
+}
+
+export function printUpdateHelp({ stream = process.stdout } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const lines = [
+    '',
+    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('update')} ${s.dim('TICKET-KEY [--title=...] [--description=...] [--add-labels=a,b] [--remove-labels=c] [--priority=...]')}  ${s.dim('[Pro]')}`,
+    '',
+    `  Update a narrow, named field set on a ticket (Jira/GitHub/Linear). ${s.dim('[Pro]')}`,
+    `  At least one field is required. Labels are add/remove, never a wholesale`,
+    `  replace — an unnamed label is left alone, not dropped.`,
+    '',
+    `  ${s.bold('GitHub has no priority field')}: passing ${s.brand('--priority')} against a GitHub-tracked`,
+    `  ticket is refused up front rather than silently ignored.`,
+    '',
+    `  A write can partially succeed (e.g. title updates but a label doesn't`,
+    `  resolve) — the result always reports exactly what landed.`,
+    '',
+    `  ${s.bold('OPTIONS')}`,
+    '',
+    `    ${s.brand('--title')}=${s.dim('TEXT')}         New title/summary`,
+    `    ${s.brand('--description')}=${s.dim('TEXT')}   New description`,
+    `    ${s.brand('--add-labels')}=${s.dim('a,b')}      Labels to add ${s.dim('(comma-separated)')}`,
+    `    ${s.brand('--remove-labels')}=${s.dim('c')}     Labels to remove ${s.dim('(comma-separated)')}`,
+    `    ${s.brand('--priority')}=${s.dim('NAME')}       New priority ${s.dim('(not supported on GitHub)')}`,
+    `    ${s.brand('--profile')}=${s.dim('NAME')}        Connection profile to use ${s.dim('(optional)')}`,
+    `    ${s.brand('-h')}, ${s.brand('--help')}          Show this help`,
+    '',
+    `  ${s.bold('EXAMPLES')}`,
+    '',
+    `    ${s.dim('$')} ticketlens update PROD-123 --title="Fix login on mobile"`,
+    `    ${s.dim('$')} ticketlens update PROD-123 --add-labels=urgent,backend --remove-labels=stale`,
+    `    ${s.dim('$')} ticketlens update PROD-123 --priority="High"`,
+    '',
+  ];
+  stream.write(lines.join('\n') + '\n');
+}
+
+export function printCreateHelp({ stream = process.stdout } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const lines = [
+    '',
+    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('create')} ${s.dim('--project=... [--type=...] --summary=... [--description=...]')}  ${s.dim('[Pro]')}`,
+    '',
+    `  Create a new ticket in a tracker (Jira/GitHub/Linear) with a fixed minimal`,
+    `  field set — no arbitrary custom fields. ${s.dim('[Pro]')} Unlike every other ticket-write`,
+    `  command, there is no existing ticket to operate on — the target tracker is`,
+    `  picked by ${s.brand('--profile')} (or your default profile), not a ticket key.`,
+    '',
+    `  ${s.bold('--project is tracker-specific')}: the Jira project key or Linear team key.`,
+    `  Required for Jira/Linear. GitHub ignores it — its target repo is already`,
+    `  fixed by the profile.`,
+    '',
+    `  ${s.bold('--type is Jira-only')}: the issue type, e.g. "Task" or "Bug". Required for`,
+    `  Jira. GitHub/Linear have no equivalent concept and ignore it if given.`,
+    '',
+    `  This is the highest-blast-radius command in the ticket-write family — a bad`,
+    `  ${s.brand('--project')}/${s.brand('--type')} fabricates a real, hard-to-walk-back item in a live tracker.`,
+    '',
+    `  ${s.bold('OPTIONS')}`,
+    '',
+    `    ${s.brand('--project')}=${s.dim('KEY')}     Project key (Jira) or team key (Linear) ${s.dim('(required, except GitHub)')}`,
+    `    ${s.brand('--type')}=${s.dim('NAME')}       Issue type ${s.dim('(Jira only, required there)')}`,
+    `    ${s.brand('--summary')}=${s.dim('TEXT')}    Ticket title/summary ${s.dim('(required)')}`,
+    `    ${s.brand('--description')}=${s.dim('TEXT')}  Ticket description`,
+    `    ${s.brand('--profile')}=${s.dim('NAME')}     Connection profile to use ${s.dim('(optional)')}`,
+    `    ${s.brand('-h')}, ${s.brand('--help')}       Show this help`,
+    '',
+    `  ${s.bold('EXAMPLES')}`,
+    '',
+    `    ${s.dim('$')} ticketlens create --project=PROD --type="Task" --summary="Fix login on mobile"`,
+    `    ${s.dim('$')} ticketlens create --project=ENG --summary="New Linear issue" --profile=linear-team`,
+    '',
+  ];
+  stream.write(lines.join('\n') + '\n');
+}
+
 export function printSwitchHelp({ stream = process.stdout } = {}) {
   const s = createStyler({ isTTY: stream.isTTY });
   const lines = [

package/skills/jtb/scripts/lib/jira-client.mjs

@@ -502,6 +502,61 @@ export async function postTransition(ticketKey, transitionId, opts = {}) {
   }
 }
 
+/**
+ * Lists this Jira instance's issue link types (id/name/inward/outward).
+ * Link type names are per-instance customizable — never hardcode or cache
+ * this list; callers must re-fetch fresh before every link, same principle
+ * as getTransitions().
+ */
+export async function getIssueLinkTypes(opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const url = `${baseUrl}/rest/api/${apiVersion}/issueLinkType`;
+
+  const fetchOpts = { headers: { ...buildAuthHeader(env), 'Content-Type': 'application/json' } };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
+  if (!response.ok) {
+    const err = new Error(`Jira API error ${response.status} fetching issue link types`);
+    err.status = response.status;
+    throw err;
+  }
+  const raw = await response.json();
+  return (raw.issueLinkTypes ?? []).map(t => ({ id: t.id, name: t.name, inward: t.inward, outward: t.outward }));
+}
+
+/**
+ * Creates a link between two issues. `sourceKey` is the outwardIssue (the
+ * subject of the type's outward verb, e.g. "Duplicates"), `targetKey` is
+ * the inwardIssue — direction matters and is the caller's responsibility
+ * to get right (ticket-command.mjs documents the convention).
+ */
+export async function postIssueLink(sourceKey, targetKey, typeName, opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const url = `${baseUrl}/rest/api/${apiVersion}/issueLink`;
+
+  const fetchOpts = {
+    method: 'POST',
+    headers: { ...buildAuthHeader(env), 'Content-Type': 'application/json' },
+    body: JSON.stringify({ type: { name: typeName }, outwardIssue: { key: sourceKey }, inwardIssue: { key: targetKey } }),
+  };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
+  if (!response.ok) {
+    let details;
+    try { details = await response.json(); } catch { /* body not JSON — fall through with no details */ }
+    const err = new Error(`Jira API error ${response.status} linking ${sourceKey} to ${targetKey}`);
+    err.status = response.status;
+    err.details = details;
+    throw err;
+  }
+}
+
 /**
  * Sets the issue's assignee. `assignee` is sent verbatim — the caller
  * (jira-adapter.mjs) resolves the right shape for the API version:
@@ -532,6 +587,134 @@ export async function assignIssue(ticketKey, assignee, opts = {}) {
   }
 }
 
+/**
+ * Updates a narrow, named field set on an issue. `fields` (summary,
+ * description, priority) uses plain SET semantics — the same shape Jira's
+ * own GET returns, same convention as assignIssue/postIssueLink. Labels use
+ * a separate verb-based `update.labels` array (`{add}`/`{remove}`) — Jira's
+ * REST API has no plain-replace shape for multi-value fields, only ADD/SET/
+ * REMOVE operations, a genuinely different mechanic from fields. Both keys
+ * can coexist in one request as long as a given field only appears in one
+ * of them — never both — which callers naturally satisfy since labels only
+ * ever go through `update`.
+ */
+export async function updateIssue(ticketKey, { summary, description, priority, addLabels, removeLabels } = {}, opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const url = `${baseUrl}/rest/api/${apiVersion}/issue/${encodeURIComponent(ticketKey)}`;
+
+  const fields = {};
+  if (summary !== undefined) fields.summary = summary;
+  if (description !== undefined) fields.description = apiVersion === 3 ? textToAdf(description) : description;
+  if (priority !== undefined) fields.priority = { name: priority };
+
+  const labelOps = [
+    ...(addLabels ?? []).map(label => ({ add: label })),
+    ...(removeLabels ?? []).map(label => ({ remove: label })),
+  ];
+
+  const body = {};
+  if (Object.keys(fields).length > 0) body.fields = fields;
+  if (labelOps.length > 0) body.update = { labels: labelOps };
+
+  const fetchOpts = {
+    method: 'PUT',
+    headers: { ...buildAuthHeader(env), 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
+  if (!response.ok) {
+    let details;
+    try { details = await response.json(); } catch { /* body not JSON — fall through with no details */ }
+    const err = new Error(`Jira API error ${response.status} updating ${ticketKey}`);
+    err.status = response.status;
+    err.details = details;
+    throw err;
+  }
+}
+
+/**
+ * Discovers the issue types actually configured for a project — used only
+ * to enrich a ticket_create failure message with real, current options,
+ * never as a client-side pre-validation step (issuetype validity is still
+ * surfaced via the tracker's own 400, same design choice as createIssue
+ * itself). A single, unpaginated call: real-world Jira projects rarely
+ * exceed a handful to a few dozen issue types (well under the endpoint's
+ * own default maxResults=50), and a truncated list here would only ever
+ * under-inform an error message, never break the actual write path — full
+ * pagination (as fetchProjects needs, since an org's total project count
+ * has no such natural ceiling) would be disproportionate complexity for
+ * an enrichment-only feature.
+ *
+ * v2 (Server/DC) and v3 (Cloud) return genuinely different response
+ * envelopes for this same resource — confirmed directly against
+ * Atlassian's own Cloud OpenAPI spec and a live-downloaded Server/DC WADL,
+ * not assumed just because the URL pattern matches: v3 nests results under
+ * `issueTypes`, v2 under `values` (same distinction fetchProjects already
+ * makes for its own project-listing endpoint, for the same underlying
+ * reason — the two API generations were never response-shape-compatible).
+ */
+export async function fetchIssueTypes(projectKey, opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
+
+  const url = `${baseUrl}/rest/api/${apiVersion}/issue/createmeta/${encodeURIComponent(projectKey)}/issuetypes`;
+  const fetchOpts = { headers };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
+
+  if (!response.ok) {
+    const err = new Error(`Jira API error ${response.status} fetching issue types for ${projectKey}`);
+    err.status = response.status;
+    throw err;
+  }
+
+  const raw = await response.json();
+  const values = apiVersion >= 3 ? (raw.issueTypes ?? []) : (raw.values ?? []);
+  return values.map(t => ({ id: t.id, name: t.name }));
+}
+
+/**
+ * Creates a new issue. `project`/`type` are passed straight through as
+ * Jira's own {key}/{name} references — issue types are project-configurable,
+ * so validity is never pre-checked here; an invalid one surfaces Jira's own
+ * 400 with details, same design choice already made for updateIssue's
+ * priority field. No separate discovery call, no client-side field list.
+ */
+export async function createIssue({ project, type, summary, description } = {}, opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const url = `${baseUrl}/rest/api/${apiVersion}/issue`;
+
+  const fields = { project: { key: project }, issuetype: { name: type }, summary };
+  if (description !== undefined) fields.description = apiVersion === 3 ? textToAdf(description) : description;
+
+  const fetchOpts = {
+    method: 'POST',
+    headers: { ...buildAuthHeader(env), 'Content-Type': 'application/json' },
+    body: JSON.stringify({ fields }),
+  };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
+  if (!response.ok) {
+    let details;
+    try { details = await response.json(); } catch { /* body not JSON — fall through with no details */ }
+    const err = new Error(`Jira API error ${response.status} creating an issue in ${project}`);
+    err.status = response.status;
+    err.details = details;
+    throw err;
+  }
+  const raw = await response.json();
+  return { key: raw.key, id: raw.id, url: raw.self ?? null };
+}
+
 export async function fetchTicket(ticketKey, opts = {}) {
   const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), depth = 1, apiVersion = 2, timeoutMs = 10_000, expandChangelog = false, allowPrivateIp = false, _visited = new Set(), _currentDepth = 0 } = opts;
   validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);

package/skills/jtb/scripts/lib/mcp-server.mjs

@@ -23,7 +23,7 @@ import readline from 'node:readline';
 import { DEFAULT_CONFIG_DIR, getVersion } from './config.mjs';
 import { runNoteAdd } from './note-command.mjs';
 import { runRecall } from './recall-command.mjs';
-import { runTicketComment, runTicketTransitionList, runTicketTransition, runTicketAssign, runTicketDuplicates } from './ticket-command.mjs';
+import { runTicketComment, runTicketTransitionList, runTicketTransition, runTicketAssign, runTicketDuplicates, runTicketLinkList, runTicketLink, runTicketUpdate, runTicketCreate } from './ticket-command.mjs';
 
 const PROTOCOL_VERSION = '2025-11-25';
 
@@ -102,6 +102,50 @@ const TOOLS = [
       required: ['ticket'],
     },
   },
+  {
+    name: 'ticket_link',
+    description: 'List or execute a link between two tickets in their tracker (Jira/GitHub/Linear). Called with only `ticket`/`target`, lists the tracker\'s current valid link types without changing anything. Destructive when `type` and `confirm: true` are both given — writes directly to the live tracker. Direction matters: `ticket` "types" `target` (e.g. ticket duplicates target). On GitHub, executing CLOSES `ticket` as a duplicate of `target` — a state change, not just a relationship add like Jira/Linear. Requires a TicketLens Pro license.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ticket: { type: 'string', description: 'Source ticket key, e.g. PROJ-123 — the one that "types" target.' },
+        target: { type: 'string', description: 'Target ticket key, e.g. PROJ-456.' },
+        type: { type: 'string', description: 'Link type name (from the list). Omit to just list the tracker\'s current valid options. GitHub only supports "duplicate".' },
+        confirm: { type: 'boolean', description: 'Must be true, alongside `type`, to actually execute the link — a nudge and audit trail, not just a formality.' },
+      },
+      required: ['ticket', 'target'],
+    },
+  },
+  {
+    name: 'ticket_update',
+    description: 'Update a narrow, named field set on a ticket in its tracker (Jira/GitHub/Linear) — title, description, labels, priority. Labels are add/remove, never a wholesale replace: an unnamed existing label is left alone. No discovery step and no confirm required — these are reversible metadata edits, not workflow-state changes. GitHub has no priority field; passing `priority` for a GitHub-tracked ticket is refused. A call can partially succeed (e.g. title updates but a label does not resolve) — the result reports exactly what landed. Requires a TicketLens Pro license.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ticket: { type: 'string', description: 'Ticket key, e.g. PROJ-123.' },
+        title: { type: 'string', description: 'New title/summary. Omit to leave unchanged.' },
+        description: { type: 'string', description: 'New description. Omit to leave unchanged.' },
+        addLabels: { type: 'array', items: { type: 'string' }, description: 'Labels to add. Existing labels not named here are left alone.' },
+        removeLabels: { type: 'array', items: { type: 'string' }, description: 'Labels to remove.' },
+        priority: { type: 'string', description: 'New priority name, e.g. "High". Not supported on GitHub.' },
+      },
+      required: ['ticket'],
+    },
+  },
+  {
+    name: 'ticket_create',
+    description: 'Create a new ticket in a tracker (Jira/GitHub/Linear) with a fixed minimal field set — no arbitrary custom fields. Architecturally unlike every other ticket-write tool: there is no existing ticket to target, so the target tracker/project is picked by the connection profile rather than a ticket key. `project` is the Jira project key or Linear team key — required for both, ignored on GitHub (its repo is fixed by the profile). `type` is the Jira issue type — required for Jira only, ignored elsewhere. Highest blast radius of the ticket-write family: a bad project/type fabricates a real, hard-to-walk-back item in a live tracker. Requires a TicketLens Pro license.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: { type: 'string', description: 'Jira project key or Linear team key. Required for Jira/Linear; ignored on GitHub.' },
+        type: { type: 'string', description: 'Jira issue type, e.g. "Task" or "Bug". Required for Jira only; ignored on GitHub/Linear.' },
+        summary: { type: 'string', description: 'Ticket title/summary.' },
+        description: { type: 'string', description: 'Ticket description. Omit for none.' },
+      },
+      required: ['summary'],
+    },
+  },
 ];
 
 function jsonRpcResult(id, result) {
@@ -233,6 +277,92 @@ async function callTicketDuplicates(args, { configDir, runTicketDuplicatesFn })
   return ok ? { content } : { isError: true, content };
 }
 
+/**
+ * No `type` → discovery only, dispatched to the read-only list function —
+ * never touches the mutating path. `type` present → dispatched to the
+ * executing function, which itself still refuses without `confirm: true`
+ * (the MCP layer doesn't pre-empt that check, same as ticket_transition).
+ */
+async function callTicketLink(args, { configDir, runTicketLinkListFn, runTicketLinkFn }) {
+  if (!args.ticket) {
+    return { isError: true, content: [{ type: 'text', text: 'Missing required argument: ticket' }] };
+  }
+  if (!args.target) {
+    return { isError: true, content: [{ type: 'text', text: 'Missing required argument: target' }] };
+  }
+  const capture = capturingStream();
+  if (!args.type) {
+    const { ok } = await runTicketLinkListFn([args.ticket, args.target], { configDir, stream: capture });
+    const content = [{ type: 'text', text: capture.text }];
+    return ok ? { content } : { isError: true, content };
+  }
+  const cmdArgs = [args.ticket, args.target, `--type=${args.type}`];
+  if (args.confirm === true) cmdArgs.push('--confirm');
+  const { ok } = await runTicketLinkFn(cmdArgs, { configDir, stream: capture });
+  const content = [{ type: 'text', text: capture.text }];
+  return ok ? { content } : { isError: true, content };
+}
+
+/**
+ * `title`/`description`/`priority` each become one opaque cmdArgs element,
+ * same reasoning as buildNoteAddArgs/callTicketComment above. `addLabels`/
+ * `removeLabels` arrive as arrays per the MCP schema and are comma-joined
+ * into a single element (same convention buildNoteAddArgs already uses for
+ * `tags`) — parsed back apart by ticket-command.mjs's existing split(',')
+ * handling, never by re-splitting a string this function builds itself.
+ */
+function buildTicketUpdateArgs(args) {
+  const cmdArgs = [args.ticket];
+  if (args.title !== undefined) cmdArgs.push(`--title=${args.title}`);
+  if (args.description !== undefined) cmdArgs.push(`--description=${args.description}`);
+  if (args.priority !== undefined) cmdArgs.push(`--priority=${args.priority}`);
+  if (Array.isArray(args.addLabels) && args.addLabels.length > 0) cmdArgs.push(`--add-labels=${args.addLabels.join(',')}`);
+  if (Array.isArray(args.removeLabels) && args.removeLabels.length > 0) cmdArgs.push(`--remove-labels=${args.removeLabels.join(',')}`);
+  return cmdArgs;
+}
+
+/**
+ * No list-then-act split, unlike ticket_transition/ticket_link — update has
+ * no discovery step, so there is exactly one dispatch path. Whether at
+ * least one field was actually given is runTicketUpdateFn's own concern
+ * (same "don't pre-empt the underlying command" principle as ticket_link's
+ * --confirm check).
+ */
+async function callTicketUpdate(args, { configDir, runTicketUpdateFn }) {
+  if (!args.ticket) {
+    return { isError: true, content: [{ type: 'text', text: 'Missing required argument: ticket' }] };
+  }
+  const capture = capturingStream();
+  const { ok } = await runTicketUpdateFn(buildTicketUpdateArgs(args), { configDir, stream: capture });
+  const content = [{ type: 'text', text: capture.text }];
+  return ok ? { content } : { isError: true, content };
+}
+
+/**
+ * `project`/`type`/`description` each become one opaque cmdArgs element,
+ * same reasoning as buildNoteAddArgs/callTicketComment above. Unlike every
+ * other ticket-write tool, there is no `ticket` argument — creation has no
+ * existing ticket to target.
+ */
+function buildTicketCreateArgs(args) {
+  const cmdArgs = [];
+  if (args.project !== undefined) cmdArgs.push(`--project=${args.project}`);
+  if (args.type !== undefined) cmdArgs.push(`--type=${args.type}`);
+  cmdArgs.push(`--summary=${args.summary}`);
+  if (args.description !== undefined) cmdArgs.push(`--description=${args.description}`);
+  return cmdArgs;
+}
+
+async function callTicketCreate(args, { configDir, runTicketCreateFn }) {
+  if (!args.summary) {
+    return { isError: true, content: [{ type: 'text', text: 'Missing required argument: summary' }] };
+  }
+  const capture = capturingStream();
+  const { ok } = await runTicketCreateFn(buildTicketCreateArgs(args), { configDir, stream: capture });
+  const content = [{ type: 'text', text: capture.text }];
+  return ok ? { content } : { isError: true, content };
+}
+
 async function handleToolsCall(params, deps) {
   const { name, arguments: args = {} } = params ?? {};
   if (name === 'recall_add') return callRecallAdd(args, deps);
@@ -241,10 +371,13 @@ async function handleToolsCall(params, deps) {
   if (name === 'ticket_transition') return callTicketTransition(args, deps);
   if (name === 'ticket_assign') return callTicketAssign(args, deps);
   if (name === 'ticket_duplicates') return callTicketDuplicates(args, deps);
+  if (name === 'ticket_link') return callTicketLink(args, deps);
+  if (name === 'ticket_update') return callTicketUpdate(args, deps);
+  if (name === 'ticket_create') return callTicketCreate(args, deps);
   return { isError: true, content: [{ type: 'text', text: `Unknown tool: ${name}` }] };
 }
 
-async function handleMessage(raw, { configDir, runNoteAddFn, runRecallFn, runTicketCommentFn, runTicketTransitionListFn, runTicketTransitionFn, runTicketAssignFn, runTicketDuplicatesFn }) {
+async function handleMessage(raw, { configDir, runNoteAddFn, runRecallFn, runTicketCommentFn, runTicketTransitionListFn, runTicketTransitionFn, runTicketAssignFn, runTicketDuplicatesFn, runTicketLinkListFn, runTicketLinkFn, runTicketUpdateFn, runTicketCreateFn }) {
   let msg;
   try {
     msg = JSON.parse(raw);
@@ -274,7 +407,7 @@ async function handleMessage(raw, { configDir, runNoteAddFn, runRecallFn, runTic
 
   if (method === 'tools/call') {
     try {
-      const result = await handleToolsCall(params, { configDir, runNoteAddFn, runRecallFn, runTicketCommentFn, runTicketTransitionListFn, runTicketTransitionFn, runTicketAssignFn, runTicketDuplicatesFn });
+      const result = await handleToolsCall(params, { configDir, runNoteAddFn, runRecallFn, runTicketCommentFn, runTicketTransitionListFn, runTicketTransitionFn, runTicketAssignFn, runTicketDuplicatesFn, runTicketLinkListFn, runTicketLinkFn, runTicketUpdateFn, runTicketCreateFn });
       return jsonRpcResult(id, result);
     } catch (err) {
       return jsonRpcError(id ?? null, -32603, `Internal error: ${err.message}`);
@@ -302,6 +435,10 @@ export function runMcpServer({
   runTicketTransitionFn = runTicketTransition,
   runTicketAssignFn = runTicketAssign,
   runTicketDuplicatesFn = runTicketDuplicates,
+  runTicketLinkListFn = runTicketLinkList,
+  runTicketLinkFn = runTicketLink,
+  runTicketUpdateFn = runTicketUpdate,
+  runTicketCreateFn = runTicketCreate,
 } = {}) {
   // A client can disconnect mid-write (EPIPE) at any time on a long-lived
   // process — an unhandled 'error' event on either stream would otherwise
@@ -321,7 +458,7 @@ export function runMcpServer({
     // never resolving (a dropped rejection isn't a resolution) — the
     // server would hang on shutdown instead of exiting.
     queue = queue.then(async () => {
-      const response = await handleMessage(line, { configDir, runNoteAddFn, runRecallFn, runTicketCommentFn, runTicketTransitionListFn, runTicketTransitionFn, runTicketAssignFn, runTicketDuplicatesFn });
+      const response = await handleMessage(line, { configDir, runNoteAddFn, runRecallFn, runTicketCommentFn, runTicketTransitionListFn, runTicketTransitionFn, runTicketAssignFn, runTicketDuplicatesFn, runTicketLinkListFn, runTicketLinkFn, runTicketUpdateFn, runTicketCreateFn });
       if (response) stdout.write(response);
     }).catch(() => {});
   });