ticketlens 0.35.0 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "description": "Jira CLI for developers — fetch ticket context, triage your queue, and stop tab-switching. Zero dependencies, all local.",
   "type": "module",
   "bin": {

package/skills/jtb/SKILL.md

@@ -1,4 +1,4 @@
-<!-- jtb-skill-version: 0.28.0 -->
+<!-- jtb-skill-version: 0.29.0 -->
 ---
 name: jtb
 description: Fetch a Jira ticket's full context (description, comments, linked issues, code references) and assemble a structured TicketBrief for implementation planning. Use when user types /jtb, mentions a Jira ticket key, or wants to plan work from a Jira ticket.
@@ -284,7 +284,7 @@ ticketlens duplicates PROD-1234                               # find likely dupl
 
 `assign` is self-assign only — `--to` must be `me`. There is no way to assign to anyone else yet; don't attempt a workaround (e.g. via `comment`) if the user asks for that — tell them it isn't supported.
 
-`duplicates` lists likely-duplicate tickets in the same project, ranked by local title/description overlap — no tracker scores similarity server-side, so treat a match as a nudge for the user to check manually, never as a confirmed duplicate to act on unprompted (e.g. don't auto-close or auto-comment based on a match). `--threshold=N` (0–1, default 0.35) tightens or loosens what counts as a match.
+`duplicates` lists likely-duplicate tickets in the same project. On Jira, any ticket already linked as a "Duplicate" is always listed first — that's a confirmed relationship a human already recorded, not a heuristic. Everything else is ranked by local title/description overlap — no tracker scores similarity server-side, so treat those as a nudge for the user to check manually, never as a confirmed duplicate to act on unprompted (e.g. don't auto-close or auto-comment based on a match). `--threshold=N` (0–1, default 0.35) tightens or loosens what counts as a text-match — it has no effect on Jira-linked duplicates, which are always shown.
 
 The three write actions (comment/transition/assign) have a short local debounce (10s) against an accidental double-fire, and every write is appended to a local audit log (`~/.ticketlens/ticket-action-log.jsonl`). A write that times out is never retried automatically — surface the failure to the user rather than silently re-attempting, since a ticket write isn't naturally idempotent the way a Recall note save is. `duplicates` has neither, since nothing is written.
 

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

@@ -751,8 +751,10 @@ export function printDuplicatesHelp({ stream = process.stdout } = {}) {
     '',
     `  Find likely duplicate tickets in the same project (Jira/GitHub/Linear). ${s.dim('[Pro]')}`,
     `  Read-only — lists possible matches, never links or changes anything.`,
-    `  No tracker scores similarity server-side, so ranking happens locally`,
-    `  from title/description overlap. Not exact — treat it as a nudge to check.`,
+    `  On Jira, any ticket already linked as a "Duplicate" is always listed first —`,
+    `  that's a confirmed relationship, not a guess. Everything else comes from a`,
+    `  local title/description overlap score (no tracker scores similarity`,
+    `  server-side) — not exact, treat those as a nudge to check.`,
     '',
     `  ${s.bold('OPTIONS')}`,
     '',

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

@@ -93,6 +93,10 @@ export function normalizeTicket(raw) {
       return {
         direction,
         linkType: link.type.name,
+        // The actual directional wording ("is duplicated by" / "duplicates") as
+        // named in Jira itself, not just the link type's generic name — lets
+        // callers show the user's own words instead of inventing new phrasing.
+        linkPhrase: direction === 'outward' ? link.type.outward : link.type.inward,
         key: issue.key,
         summary: issue.fields.summary,
         status: issue.fields.status?.name ?? null,

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

@@ -93,7 +93,7 @@ const TOOLS = [
   },
   {
     name: 'ticket_duplicates',
-    description: 'Find likely duplicate tickets in the same project (Jira/GitHub/Linear). Read-only — never links or changes anything; no tracker scores similarity server-side, so ranking is local and approximate. Requires a TicketLens Pro license.',
+    description: 'Find likely duplicate tickets in the same project (Jira/GitHub/Linear). Read-only — never links or changes anything. On Jira, any ticket already linked as a "Duplicate" is always included first (a confirmed relationship, not a guess); everything else comes from a local, approximate title/description overlap score, since no tracker scores similarity server-side. Requires a TicketLens Pro license.',
     inputSchema: {
       type: 'object',
       properties: {

package/skills/jtb/scripts/lib/ticket-command.mjs

@@ -45,10 +45,10 @@ function refuseGithubAttachments(adapter, attachPaths, stream) {
   return true;
 }
 
-function formatAttachSummary(attachResult) {
+function formatAttachSummary(attachResult, s) {
   if (!attachResult) return '';
   const lines = [];
-  for (const u of attachResult.uploaded) lines.push(`  Attached ${u.filename}${u.url ? ` (${u.url})` : ''}\n`);
+  for (const u of attachResult.uploaded) lines.push(`  ${s.green('✔')} Attached ${s.bold(u.filename)}${u.url ? ` (${u.url})` : ''}\n`);
   for (const e of attachResult.errors) lines.push(`  Failed to attach ${e.path}: ${e.message}\n`);
   if (attachResult.droppedCount > 0) lines.push(`  ${attachResult.droppedCount} attachment(s) dropped — exceeds the ${MAX_ATTACHMENTS}-file limit per call.\n`);
   return lines.join('');
@@ -190,11 +190,14 @@ function describeAppliedFields(applied) {
   return parts.join(', ');
 }
 
-function formatUpdateResult(ticketKey, { applied, errors }) {
+function formatUpdateResult(ticketKey, { applied, errors }, s) {
   const appliedText = describeAppliedFields(applied);
   const errorText = Object.entries(errors).map(([field, info]) => formatFieldError(field, info)).join('; ');
-  if (appliedText && !errorText) return `  ${ticketKey} updated: ${appliedText}.\n`;
-  if (appliedText && errorText) return `  ${ticketKey} partially updated: ${appliedText}. Failed: ${errorText}.\n`;
+  // Success/partial get the styled brand+bold key; total failure stays plain,
+  // consistent with every other refusal/error message in this file (e.g. the
+  // GitHub-priority-refusal line just above in runTicketUpdate).
+  if (appliedText && !errorText) return `  ${s.green('✔')} ${s.brand(s.bold(ticketKey))} updated: ${s.bold(appliedText)}.\n`;
+  if (appliedText && errorText) return `  ${s.yellow('~')} ${s.brand(s.bold(ticketKey))} partially updated: ${s.bold(appliedText)}. Failed: ${errorText}.\n`;
   return `  Nothing updated on ${ticketKey}. Failed: ${errorText}.\n`;
 }
 
@@ -267,6 +270,7 @@ export async function runTicketComment(cmdArgs, {
 
   const adapter = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
   if (!adapter) return { ok: false };
+  const s = createStyler({ isTTY: stream.isTTY });
 
   // Uploaded BEFORE the comment write so a tracker capable of inline
   // rendering (Jira Server/DC via wiki markup, Jira Cloud via a real ADF
@@ -287,13 +291,13 @@ export async function runTicketComment(cmdArgs, {
     // actually landed) — a partial attach failure is reconstructable from
     // the difference between the two, not just silently absent from audit.
     logActionFn({ ticketKey, action: 'comment', actor, tracker: adapter.type, detail: { id: result.id, attachPaths, attachedFilenames: (attachResult?.uploaded ?? []).map(a => a.filename) } }, { configDir });
-    stream.write(`  Comment posted to ${ticketKey}${result.url ? ` (${result.url})` : ''}\n` + formatAttachSummary(attachResult));
+    stream.write(`  ${s.green('✔')} Comment posted to ${s.brand(s.bold(ticketKey))}${result.url ? ` (${result.url})` : ''}\n` + formatAttachSummary(attachResult, s));
     return { ok: true };
   } catch (err) {
     // Attachments (if any) genuinely landed on the tracker before this
     // write was attempted — formatAttachSummary is still shown here so a
     // caller retrying the whole command doesn't blindly re-upload them.
-    stream.write(formatWriteFailure(ticketKey, err) + formatAttachSummary(attachResult));
+    stream.write(formatWriteFailure(ticketKey, err) + formatAttachSummary(attachResult, s));
     return { ok: false };
   }
 }
@@ -323,13 +327,14 @@ export async function runTicketTransitionList(cmdArgs, {
 
   try {
     const options = await adapter.getTransitions(ticketKey);
+    const s = createStyler({ isTTY: stream.isTTY });
     if (options.length === 0) {
-      stream.write(`  No valid transitions available for ${ticketKey}.\n`);
+      stream.write(`  No valid transitions available for ${s.brand(s.bold(ticketKey))}.\n`);
       return { ok: true, options: [] };
     }
-    stream.write(`  Valid transitions for ${ticketKey}:\n`);
-    for (const o of options) stream.write(`    - ${o.name}\n`);
-    stream.write(`  Run again with --target="<name>" --confirm to execute.\n`);
+    stream.write(`  Valid transitions for ${s.brand(s.bold(ticketKey))}:\n\n`);
+    for (const o of options) stream.write(`    ${s.brand('●')} ${o.name}\n`);
+    stream.write(`\n  Run again with --target="<name>" --confirm to execute.\n`);
     return { ok: true, options };
   } catch (err) {
     stream.write(formatWriteFailure(ticketKey, err));
@@ -389,7 +394,8 @@ export async function runTicketTransition(cmdArgs, {
     }
     recordActionFn(ticketKey, 'transition', { configDir });
     logActionFn({ ticketKey, action: 'transition', actor, tracker: adapter.type, detail: { to: result.to } }, { configDir });
-    stream.write(`  ${ticketKey} transitioned to "${result.to}".\n`);
+    const s = createStyler({ isTTY: stream.isTTY });
+    stream.write(`  ${s.green('✔')} ${s.brand(s.bold(ticketKey))} transitioned to ${s.bold(`"${result.to}"`)}.\n`);
     return { ok: true };
   } catch (err) {
     stream.write(formatWriteFailure(ticketKey, err));
@@ -443,7 +449,8 @@ export async function runTicketAssign(cmdArgs, {
     const result = await adapter.assignToSelf(ticketKey);
     recordActionFn(ticketKey, 'assign', { configDir });
     logActionFn({ ticketKey, action: 'assign', actor, tracker: adapter.type, detail: { assignee: result.assignee } }, { configDir });
-    stream.write(`  ${ticketKey} assigned to ${result.assignee}.\n`);
+    const s = createStyler({ isTTY: stream.isTTY });
+    stream.write(`  ${s.green('✔')} ${s.brand(s.bold(ticketKey))} assigned to ${s.bold(result.assignee)}.\n`);
     return { ok: true };
   } catch (err) {
     stream.write(formatWriteFailure(ticketKey, err));
@@ -485,11 +492,27 @@ export async function runTicketDuplicates(cmdArgs, {
   if (!adapter) return { ok: false };
 
   try {
-    const source = await adapter.fetchTicket(ticketKey);
+    // depth: 0 — only the shallow linkedIssues list is needed (for explicit
+    // Duplicate links, below); the default depth:1 would also recursively
+    // fetch full details of every linked ticket just to discard them here.
+    const source = await adapter.fetchTicket(ticketKey, { depth: 0 });
     const searchText = [source.summary, source.description].filter(Boolean).join(' ');
     const candidates = await adapter.findCandidates(searchText, ticketKey);
     const scoreOpts = threshold !== undefined ? { threshold } : {};
-    const results = scoreCandidates({ key: ticketKey, summary: source.summary, description: source.description }, candidates, scoreOpts);
+    const textMatches = scoreCandidates({ key: ticketKey, summary: source.summary, description: source.description }, candidates, scoreOpts);
+
+    // A human already said these are duplicates — always include them,
+    // regardless of --threshold, ahead of anything the local scorer finds.
+    // Jira doesn't enforce uniqueness of link-type+target pairs, so the same
+    // key could appear via two separately-typed "duplicate-ish" links —
+    // de-duped against itself here, not just against textMatches below.
+    const seenLinkedKeys = new Set();
+    const linkedDuplicates = (source.linkedIssues ?? [])
+      .filter(l => /duplicate/i.test(l.linkType))
+      .filter(l => !seenLinkedKeys.has(l.key) && seenLinkedKeys.add(l.key))
+      .map(l => ({ key: l.key, summary: l.summary, linked: true, linkPhrase: l.linkPhrase }));
+    const linkedKeys = new Set(linkedDuplicates.map(l => l.key));
+    const results = [...linkedDuplicates, ...textMatches.filter(r => !linkedKeys.has(r.key))];
 
     const s = createStyler({ isTTY: stream.isTTY });
     stream.write(`  ${s.brand(s.bold(ticketKey))}: ${s.bold(source.summary ?? '')}\n\n`);
@@ -500,6 +523,10 @@ export async function runTicketDuplicates(cmdArgs, {
     }
     stream.write(`  Possible duplicates:\n\n`);
     for (const r of results) {
+      if (r.linked) {
+        stream.write(`    ${s.brand('●')} ${s.bold(r.key)} (${s.green(`Jira-linked — ${r.linkPhrase}`)}) — ${r.summary}\n`);
+        continue;
+      }
       const pct = Math.round(r.score * 100);
       const pctColor = matchColor(pct, s);
       stream.write(`    ${s.brand('●')} ${s.bold(r.key)} (${pctColor(`${pct}% match`)}) — ${r.summary}\n`);
@@ -543,12 +570,14 @@ export async function runTicketLinkList(cmdArgs, {
 
   try {
     const types = await adapter.getLinkTypes();
+    const s = createStyler({ isTTY: stream.isTTY });
     if (types.length === 0) {
-      stream.write(`  No link types available for ${sourceKey} → ${targetKey} on ${adapter.type}.\n`);
+      stream.write(`  No link types available for ${s.brand(s.bold(sourceKey))} → ${s.brand(s.bold(targetKey))} on ${adapter.type}.\n`);
       return { ok: true, types: [] };
     }
-    stream.write(`  Available link types for ${sourceKey} → ${targetKey} (${adapter.type}):\n`);
-    for (const t of types) stream.write(`    - ${t}\n`);
+    stream.write(`  Available link types for ${s.brand(s.bold(sourceKey))} → ${s.brand(s.bold(targetKey))} (${adapter.type}):\n\n`);
+    for (const t of types) stream.write(`    ${s.brand('●')} ${t}\n`);
+    stream.write('\n');
     if (adapter.type === 'github') {
       stream.write(`  Note: GitHub has no generic link relationship — linking will CLOSE ${sourceKey} as a duplicate of ${targetKey}.\n`);
     }
@@ -627,10 +656,11 @@ export async function runTicketLink(cmdArgs, {
     }
     recordActionFn(cooldownKey, 'link', { configDir });
     logActionFn({ ticketKey: sourceKey, action: 'link', actor, tracker: adapter.type, detail: { targetKey, type } }, { configDir });
+    const s = createStyler({ isTTY: stream.isTTY });
     stream.write(
       adapter.type === 'github'
-        ? `  ${sourceKey} closed as a duplicate of ${targetKey}.\n`
-        : `  ${sourceKey} linked to ${targetKey} as "${type}".\n`,
+        ? `  ${s.green('✔')} ${s.brand(s.bold(sourceKey))} closed as a duplicate of ${s.brand(s.bold(targetKey))}.\n`
+        : `  ${s.green('✔')} ${s.brand(s.bold(sourceKey))} linked to ${s.brand(s.bold(targetKey))} as ${s.bold(`"${type}"`)}.\n`,
     );
     return { ok: true };
   } catch (err) {
@@ -713,7 +743,7 @@ export async function runTicketUpdate(cmdArgs, {
       recordActionFn(ticketKey, 'update', { configDir });
       logActionFn({ ticketKey, action: 'update', actor, tracker: adapter.type, detail: { ...result.applied, failed: Object.keys(result.errors) } }, { configDir });
     }
-    stream.write(formatUpdateResult(ticketKey, result));
+    stream.write(formatUpdateResult(ticketKey, result, createStyler({ isTTY: stream.isTTY })));
     return hasErrors ? { ok: false, applied: result.applied, errors: result.errors } : { ok: true, applied: result.applied };
   } catch (err) {
     stream.write(formatWriteFailure(ticketKey, err));
@@ -774,6 +804,7 @@ export async function runTicketCreate(cmdArgs, {
 
   const adapter = resolveTicketAdapter(undefined, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
   if (!adapter) return { ok: false };
+  const s = createStyler({ isTTY: stream.isTTY });
   const attachRefused = refuseGithubAttachments(adapter, attachPaths, stream);
 
   if (adapter.type !== 'github' && !project) {
@@ -863,6 +894,6 @@ export async function runTicketCreate(cmdArgs, {
     }
   }
 
-  stream.write(`  Created ${result.key}${result.url ? ` (${result.url})` : ''}\n` + formatAttachSummary(attachResult));
+  stream.write(`  ${s.green('✔')} Created ${s.brand(s.bold(result.key))}${result.url ? ` (${result.url})` : ''}\n` + formatAttachSummary(attachResult, s));
   return { ok: true, key: result.key };
 }